File Coverage

blib/lib/Mail/IMAPClient/Thread.pm
Criterion Covered Total %
statement 347 391 88.7
branch 100 212 47.1
condition 34 75 45.3
subroutine 19 20 95.0
pod 0 1 0.0
total 500 699 71.5


line stmt bran cond sub pod time code
1             #
2             # This parser was generated with
3             # Parse::RecDescent version 1.967015
4             #
5              
6             package Mail::IMAPClient::Thread;
7 1     1   79848 use Parse::RecDescent;
  1         45125  
  1         10  
8             { my $ERRORS;
9              
10              
11             package Parse::RecDescent::Mail::IMAPClient::Thread;
12 1     1   66 use strict;
  1         2  
  1         26  
13 1     1   14 use vars qw($skip $AUTOLOAD );
  1         1  
  1         128  
14             @Parse::RecDescent::Mail::IMAPClient::Thread::ISA = ();
15             $skip = '\\s*';
16              
17              
18              
19             {
20             local $SIG{__WARN__} = sub {0};
21             # PRETEND TO BE IN Parse::RecDescent NAMESPACE
22             *Parse::RecDescent::Mail::IMAPClient::Thread::AUTOLOAD = sub
23             {
24 1     1   7 no strict 'refs';
  1         2  
  1         103  
25              
26 0     0   0 ${"AUTOLOAD"} =~ s/^Parse::RecDescent::Mail::IMAPClient::Thread/Parse::RecDescent/;
  0         0  
27 0         0 goto &{${"AUTOLOAD"}};
  0         0  
  0         0  
28             }
29             }
30              
31             push @Parse::RecDescent::Mail::IMAPClient::Thread::ISA, 'Parse::RecDescent';
32             # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
33             sub Parse::RecDescent::Mail::IMAPClient::Thread::NUMBER
34             {
35 170     170   286 my $thisparser = $_[0];
36 1     1   6 use vars q{$tracelevel};
  1         3  
  1         699  
37 170   50     348 local $tracelevel = ($tracelevel||0)+1;
38 170         231 $ERRORS = 0;
39 170         300 my $thisrule = $thisparser->{"rules"}{"NUMBER"};
40              
41 170 50       310 Parse::RecDescent::_trace(q{Trying rule: [NUMBER]},
42             Parse::RecDescent::_tracefirst($_[1]),
43             q{NUMBER},
44             $tracelevel)
45             if defined $::RD_TRACE;
46              
47            
48 170         217 my $err_at = @{$thisparser->{errors}};
  170         270  
49              
50 170         390 my $score;
51             my $score_return;
52 170         0 my $_tok;
53 170         239 my $return = undef;
54 170         210 my $_matched=0;
55 170         199 my $commit=0;
56 170         242 my @item = ();
57 170         223 my %item = ();
58 170         210 my $repeating = $_[2];
59 170         226 my $_noactions = $_[3];
60 170 50       281 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
  170         201  
  170         265  
61 170         250 my $_itempos = $_[5];
62 170 50       301 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
63 170         358 my $text;
64             my $lastsep;
65 170         0 my $current_match;
66 170         330 my $expectation = new Parse::RecDescent::Expectation(q{/\\d+/});
67 170         998 $expectation->at($_[1]);
68            
69 170         665 my $thisline;
70 170         414 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
71              
72            
73              
74 170   33     1175 while (!$_matched && !$commit)
75             {
76            
77 170 50       315 Parse::RecDescent::_trace(q{Trying production: [/\\d+/]},
78             Parse::RecDescent::_tracefirst($_[1]),
79             q{NUMBER},
80             $tracelevel)
81             if defined $::RD_TRACE;
82 170         305 my $thisprod = $thisrule->{"prods"}[0];
83 170         312 $text = $_[1];
84 170         219 my $_savetext;
85 170         282 @item = (q{NUMBER});
86 170         304 %item = (__RULE__ => q{NUMBER});
87 170         263 my $repcount = 0;
88              
89              
90 170 50       298 Parse::RecDescent::_trace(q{Trying terminal: [/\\d+/]}, Parse::RecDescent::_tracefirst($text),
91             q{NUMBER},
92             $tracelevel)
93             if defined $::RD_TRACE;
94 170         304 undef $lastsep;
95 170         368 $expectation->is(q{})->at($text);
96            
97              
98 170 100 66     1811 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:\d+)/)
  170 100       1405  
99             {
100 84 50       272 $text = $lastsep . $text if defined $lastsep;
101 84         279 $expectation->failed();
102 84 50       394 Parse::RecDescent::_trace(q{<>},
103             Parse::RecDescent::_tracefirst($text))
104             if defined $::RD_TRACE;
105              
106 84         168 last;
107             }
108 86         412 $current_match = substr($text, $-[0], $+[0] - $-[0]);
109 86         270 substr($text,0,length($current_match),q{});
110 86 50       180 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
111             . $current_match . q{])},
112             Parse::RecDescent::_tracefirst($text))
113             if defined $::RD_TRACE;
114 86         221 push @item, $item{__PATTERN1__}=$current_match;
115            
116              
117 86 50       151 Parse::RecDescent::_trace(q{>>Matched production: [/\\d+/]<<},
118             Parse::RecDescent::_tracefirst($text),
119             q{NUMBER},
120             $tracelevel)
121             if defined $::RD_TRACE;
122              
123              
124              
125 86         117 $_matched = 1;
126 86         171 last;
127             }
128              
129              
130 170 100 66     489 unless ( $_matched || defined($score) )
131             {
132            
133              
134 84         144 $_[1] = $text; # NOT SURE THIS IS NEEDED
135 84 50       144 Parse::RecDescent::_trace(q{<>},
136             Parse::RecDescent::_tracefirst($_[1]),
137             q{NUMBER},
138             $tracelevel)
139             if defined $::RD_TRACE;
140 84         397 return undef;
141             }
142 86 50 33     268 if (!defined($return) && defined($score))
143             {
144 0 0       0 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
145             q{NUMBER},
146             $tracelevel)
147             if defined $::RD_TRACE;
148 0         0 $return = $score_return;
149             }
150 86         110 splice @{$thisparser->{errors}}, $err_at;
  86         210  
151 86 50       250 $return = $item[$#item] unless defined $return;
152 86 50       162 if (defined $::RD_TRACE)
153             {
154 0         0 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
155             $return . q{])}, "",
156             q{NUMBER},
157             $tracelevel);
158 0         0 Parse::RecDescent::_trace(q{(consumed: [} .
159             Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
160             Parse::RecDescent::_tracefirst($text),
161             , q{NUMBER},
162             $tracelevel)
163             }
164 86         185 $_[1] = $text;
165 86         499 return $return;
166             }
167              
168             # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
169             sub Parse::RecDescent::Mail::IMAPClient::Thread::start
170             {
171 2     2   2129 my $thisparser = $_[0];
172 1     1   8 use vars q{$tracelevel};
  1         3  
  1         959  
173 2   50     13 local $tracelevel = ($tracelevel||0)+1;
174 2         5 $ERRORS = 0;
175 2         6 my $thisrule = $thisparser->{"rules"}{"start"};
176              
177 2 50       5 Parse::RecDescent::_trace(q{Trying rule: [start]},
178             Parse::RecDescent::_tracefirst($_[1]),
179             q{start},
180             $tracelevel)
181             if defined $::RD_TRACE;
182              
183            
184 2         4 my $err_at = @{$thisparser->{errors}};
  2         5  
185              
186 2         7 my $score;
187             my $score_return;
188 2         0 my $_tok;
189 2         4 my $return = undef;
190 2         2 my $_matched=0;
191 2         4 my $commit=0;
192 2         5 my @item = ();
193 2         4 my %item = ();
194 2         4 my $repeating = $_[2];
195 2         3 my $_noactions = $_[3];
196 2 50       8 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
  2         3  
  2         5  
197 2         9 my $_itempos = $_[5];
198 2 50       7 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
199 2         7 my $text;
200             my $lastsep;
201 2         0 my $current_match;
202 2         11 my $expectation = new Parse::RecDescent::Expectation(q{/^\\* THREAD /i});
203 2         22 $expectation->at($_[1]);
204            
205 2         13 my $thisline;
206 2         11 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
207              
208            
209              
210 2   33     21 while (!$_matched && !$commit)
211             {
212            
213 2 50       7 Parse::RecDescent::_trace(q{Trying production: [/^\\* THREAD /i thread]},
214             Parse::RecDescent::_tracefirst($_[1]),
215             q{start},
216             $tracelevel)
217             if defined $::RD_TRACE;
218 2         10 my $thisprod = $thisrule->{"prods"}[0];
219 2         4 $text = $_[1];
220 2         4 my $_savetext;
221 2         4 @item = (q{start});
222 2         19 %item = (__RULE__ => q{start});
223 2         4 my $repcount = 0;
224              
225              
226 2 50       6 Parse::RecDescent::_trace(q{Trying terminal: [/^\\* THREAD /i]}, Parse::RecDescent::_tracefirst($text),
227             q{start},
228             $tracelevel)
229             if defined $::RD_TRACE;
230 2         5 undef $lastsep;
231 2         8 $expectation->is(q{})->at($text);
232            
233              
234 2 50 33     39 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:^\* THREAD )/i)
  2 50       27  
235             {
236 0 0       0 $text = $lastsep . $text if defined $lastsep;
237 0         0 $expectation->failed();
238 0 0       0 Parse::RecDescent::_trace(q{<>},
239             Parse::RecDescent::_tracefirst($text))
240             if defined $::RD_TRACE;
241              
242 0         0 last;
243             }
244 2         15 $current_match = substr($text, $-[0], $+[0] - $-[0]);
245 2         10 substr($text,0,length($current_match),q{});
246 2 50       6 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
247             . $current_match . q{])},
248             Parse::RecDescent::_tracefirst($text))
249             if defined $::RD_TRACE;
250 2         6 push @item, $item{__PATTERN1__}=$current_match;
251            
252              
253 2 50       6 Parse::RecDescent::_trace(q{Trying repeated subrule: [thread]},
254             Parse::RecDescent::_tracefirst($text),
255             q{start},
256             $tracelevel)
257             if defined $::RD_TRACE;
258 2         16 $expectation->is(q{thread})->at($text);
259            
260 2 50   50   33 unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::Thread::thread, 0, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
  50         91  
261             {
262 0 0       0 Parse::RecDescent::_trace(q{<>},
263             Parse::RecDescent::_tracefirst($text),
264             q{start},
265             $tracelevel)
266             if defined $::RD_TRACE;
267 0         0 last;
268             }
269 2 50       74 Parse::RecDescent::_trace(q{>>Matched repeated subrule: [thread]<< (}
270             . @$_tok . q{ times)},
271              
272             Parse::RecDescent::_tracefirst($text),
273             q{start},
274             $tracelevel)
275             if defined $::RD_TRACE;
276 2         8 $item{q{thread(s?)}} = $_tok;
277 2         4 push @item, $_tok;
278            
279              
280              
281 2 50       7 Parse::RecDescent::_trace(q{Trying action},
282             Parse::RecDescent::_tracefirst($text),
283             q{start},
284             $tracelevel)
285             if defined $::RD_TRACE;
286            
287              
288 2 50       9 $_tok = ($_noactions) ? 0 : do {
289 2   50     19 $return=$item{'thread(s?)'}||undef;
290             };
291 2 50       8 unless (defined $_tok)
292             {
293 0 0       0 Parse::RecDescent::_trace(q{<> (return value: [undef])})
294             if defined $::RD_TRACE;
295 0         0 last;
296             }
297 2 50       7 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
298             . $_tok . q{])},
299             Parse::RecDescent::_tracefirst($text))
300             if defined $::RD_TRACE;
301 2         5 push @item, $_tok;
302 2         6 $item{__ACTION1__}=$_tok;
303            
304              
305 2 50       7 Parse::RecDescent::_trace(q{>>Matched production: [/^\\* THREAD /i thread]<<},
306             Parse::RecDescent::_tracefirst($text),
307             q{start},
308             $tracelevel)
309             if defined $::RD_TRACE;
310              
311              
312              
313 2         4 $_matched = 1;
314 2         6 last;
315             }
316              
317              
318 2 50 33     9 unless ( $_matched || defined($score) )
319             {
320            
321              
322 0         0 $_[1] = $text; # NOT SURE THIS IS NEEDED
323 0 0       0 Parse::RecDescent::_trace(q{<>},
324             Parse::RecDescent::_tracefirst($_[1]),
325             q{start},
326             $tracelevel)
327             if defined $::RD_TRACE;
328 0         0 return undef;
329             }
330 2 50 33     7 if (!defined($return) && defined($score))
331             {
332 0 0       0 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
333             q{start},
334             $tracelevel)
335             if defined $::RD_TRACE;
336 0         0 $return = $score_return;
337             }
338 2         3 splice @{$thisparser->{errors}}, $err_at;
  2         6  
339 2 50       6 $return = $item[$#item] unless defined $return;
340 2 50       7 if (defined $::RD_TRACE)
341             {
342 0         0 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
343             $return . q{])}, "",
344             q{start},
345             $tracelevel);
346 0         0 Parse::RecDescent::_trace(q{(consumed: [} .
347             Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
348             Parse::RecDescent::_tracefirst($text),
349             , q{start},
350             $tracelevel)
351             }
352 2         5 $_[1] = $text;
353 2         19 return $return;
354             }
355              
356             # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
357             sub Parse::RecDescent::Mail::IMAPClient::Thread::thread
358             {
359 134     134   959 my $thisparser = $_[0];
360 1     1   8 use vars q{$tracelevel};
  1         3  
  1         1227  
361 134   50     279 local $tracelevel = ($tracelevel||0)+1;
362 134         168 $ERRORS = 0;
363 134         242 my $thisrule = $thisparser->{"rules"}{"thread"};
364              
365 134 50       257 Parse::RecDescent::_trace(q{Trying rule: [thread]},
366             Parse::RecDescent::_tracefirst($_[1]),
367             q{thread},
368             $tracelevel)
369             if defined $::RD_TRACE;
370              
371            
372 134         198 my $err_at = @{$thisparser->{errors}};
  134         224  
373              
374 134         290 my $score;
375             my $score_return;
376 134         0 my $_tok;
377 134         180 my $return = undef;
378 134         170 my $_matched=0;
379 134         178 my $commit=0;
380 134         181 my @item = ();
381 134         176 my %item = ();
382 134         187 my $repeating = $_[2];
383 134         199 my $_noactions = $_[3];
384 134 50       227 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
  134         179  
  134         221  
385 134         195 my $_itempos = $_[5];
386 134 50       254 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
387 134         293 my $text;
388             my $lastsep;
389 134         0 my $current_match;
390 134         309 my $expectation = new Parse::RecDescent::Expectation(q{'('});
391 134         834 $expectation->at($_[1]);
392            
393 134         513 my $thisline;
394 134         400 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
395              
396            
397              
398 134   33     935 while (!$_matched && !$commit)
399             {
400            
401 134 50       254 Parse::RecDescent::_trace(q{Trying production: ['(' threadmember ')']},
402             Parse::RecDescent::_tracefirst($_[1]),
403             q{thread},
404             $tracelevel)
405             if defined $::RD_TRACE;
406 134         221 my $thisprod = $thisrule->{"prods"}[0];
407 134         206 $text = $_[1];
408 134         165 my $_savetext;
409 134         228 @item = (q{thread});
410 134         220 %item = (__RULE__ => q{thread});
411 134         176 my $repcount = 0;
412              
413              
414 134 50       228 Parse::RecDescent::_trace(q{Trying terminal: ['(']},
415             Parse::RecDescent::_tracefirst($text),
416             q{thread},
417             $tracelevel)
418             if defined $::RD_TRACE;
419 134         215 undef $lastsep;
420 134         281 $expectation->is(q{})->at($text);
421            
422              
423 134 100 33     1379 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "("; 1 } and
  134 100 66     723  
  134   66     239  
  134         599  
424             substr($text,0,length($_tok)) eq $_tok and
425 66         139 do { substr($text,0,length($_tok)) = ""; 1; }
  66         169  
426             )
427             {
428 68 50       205 $text = $lastsep . $text if defined $lastsep;
429            
430 68         218 $expectation->failed();
431 68 50       263 Parse::RecDescent::_trace(q{<>},
432             Parse::RecDescent::_tracefirst($text))
433             if defined $::RD_TRACE;
434 68         138 last;
435             }
436 66 50       190 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
437             . $_tok . q{])},
438             Parse::RecDescent::_tracefirst($text))
439             if defined $::RD_TRACE;
440 66         140 push @item, $item{__STRING1__}=$_tok;
441            
442              
443 66 50       119 Parse::RecDescent::_trace(q{Trying repeated subrule: [threadmember]},
444             Parse::RecDescent::_tracefirst($text),
445             q{thread},
446             $tracelevel)
447             if defined $::RD_TRACE;
448 66         158 $expectation->is(q{threadmember})->at($text);
449            
450 66 50   170   705 unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::Thread::threadmember, 1, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
  170         303  
451             {
452 0 0       0 Parse::RecDescent::_trace(q{<>},
453             Parse::RecDescent::_tracefirst($text),
454             q{thread},
455             $tracelevel)
456             if defined $::RD_TRACE;
457 0         0 last;
458             }
459 66 50       865 Parse::RecDescent::_trace(q{>>Matched repeated subrule: [threadmember]<< (}
460             . @$_tok . q{ times)},
461              
462             Parse::RecDescent::_tracefirst($text),
463             q{thread},
464             $tracelevel)
465             if defined $::RD_TRACE;
466 66         120 $item{q{threadmember(s)}} = $_tok;
467 66         100 push @item, $_tok;
468            
469              
470              
471 66 50       120 Parse::RecDescent::_trace(q{Trying terminal: [')']},
472             Parse::RecDescent::_tracefirst($text),
473             q{thread},
474             $tracelevel)
475             if defined $::RD_TRACE;
476 66         94 undef $lastsep;
477 66         157 $expectation->is(q{')'})->at($text);
478            
479              
480 66 50 33     636 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = ")"; 1 } and
  66 50 33     360  
  66   33     118  
  66         273  
481             substr($text,0,length($_tok)) eq $_tok and
482 66         165 do { substr($text,0,length($_tok)) = ""; 1; }
  66         159  
483             )
484             {
485 0 0       0 $text = $lastsep . $text if defined $lastsep;
486            
487 0         0 $expectation->failed();
488 0 0       0 Parse::RecDescent::_trace(q{<>},
489             Parse::RecDescent::_tracefirst($text))
490             if defined $::RD_TRACE;
491 0         0 last;
492             }
493 66 50       144 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
494             . $_tok . q{])},
495             Parse::RecDescent::_tracefirst($text))
496             if defined $::RD_TRACE;
497 66         154 push @item, $item{__STRING2__}=$_tok;
498            
499              
500 66 50       110 Parse::RecDescent::_trace(q{Trying action},
501             Parse::RecDescent::_tracefirst($text),
502             q{thread},
503             $tracelevel)
504             if defined $::RD_TRACE;
505            
506              
507 66 50       121 $_tok = ($_noactions) ? 0 : do {
508 66   50     165 $return = $item{'threadmember(s)'}||undef;
509             };
510 66 50       126 unless (defined $_tok)
511             {
512 0 0       0 Parse::RecDescent::_trace(q{<> (return value: [undef])})
513             if defined $::RD_TRACE;
514 0         0 last;
515             }
516 66 50       116 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
517             . $_tok . q{])},
518             Parse::RecDescent::_tracefirst($text))
519             if defined $::RD_TRACE;
520 66         122 push @item, $_tok;
521 66         103 $item{__ACTION1__}=$_tok;
522            
523              
524 66 50       108 Parse::RecDescent::_trace(q{>>Matched production: ['(' threadmember ')']<<},
525             Parse::RecDescent::_tracefirst($text),
526             q{thread},
527             $tracelevel)
528             if defined $::RD_TRACE;
529              
530              
531              
532 66         98 $_matched = 1;
533 66         119 last;
534             }
535              
536              
537 134 100 66     331 unless ( $_matched || defined($score) )
538             {
539            
540              
541 68         113 $_[1] = $text; # NOT SURE THIS IS NEEDED
542 68 50       114 Parse::RecDescent::_trace(q{<>},
543             Parse::RecDescent::_tracefirst($_[1]),
544             q{thread},
545             $tracelevel)
546             if defined $::RD_TRACE;
547 68         305 return undef;
548             }
549 66 50 33     132 if (!defined($return) && defined($score))
550             {
551 0 0       0 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
552             q{thread},
553             $tracelevel)
554             if defined $::RD_TRACE;
555 0         0 $return = $score_return;
556             }
557 66         86 splice @{$thisparser->{errors}}, $err_at;
  66         132  
558 66 50       134 $return = $item[$#item] unless defined $return;
559 66 50       119 if (defined $::RD_TRACE)
560             {
561 0         0 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
562             $return . q{])}, "",
563             q{thread},
564             $tracelevel);
565 0         0 Parse::RecDescent::_trace(q{(consumed: [} .
566             Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
567             Parse::RecDescent::_tracefirst($text),
568             , q{thread},
569             $tracelevel)
570             }
571 66         112 $_[1] = $text;
572 66         337 return $return;
573             }
574              
575             # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
576             sub Parse::RecDescent::Mail::IMAPClient::Thread::threadmember
577             {
578 170     170   2749 my $thisparser = $_[0];
579 1     1   9 use vars q{$tracelevel};
  1         2  
  1         355  
580 170   50     363 local $tracelevel = ($tracelevel||0)+1;
581 170         233 $ERRORS = 0;
582 170         272 my $thisrule = $thisparser->{"rules"}{"threadmember"};
583              
584 170 50       311 Parse::RecDescent::_trace(q{Trying rule: [threadmember]},
585             Parse::RecDescent::_tracefirst($_[1]),
586             q{threadmember},
587             $tracelevel)
588             if defined $::RD_TRACE;
589              
590            
591 170         219 my $err_at = @{$thisparser->{errors}};
  170         308  
592              
593 170         405 my $score;
594             my $score_return;
595 170         0 my $_tok;
596 170         227 my $return = undef;
597 170         235 my $_matched=0;
598 170         206 my $commit=0;
599 170         344 my @item = ();
600 170         232 my %item = ();
601 170         216 my $repeating = $_[2];
602 170         371 my $_noactions = $_[3];
603 170 50       300 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
  170         250  
  170         261  
604 170         257 my $_itempos = $_[5];
605 170 50       318 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
606 170         358 my $text;
607             my $lastsep;
608 170         0 my $current_match;
609 170         383 my $expectation = new Parse::RecDescent::Expectation(q{NUMBER, or thread});
610 170         1020 $expectation->at($_[1]);
611            
612 170         692 my $thisline;
613 170         529 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
614              
615            
616              
617 170   33     1226 while (!$_matched && !$commit)
618             {
619            
620 170 50       333 Parse::RecDescent::_trace(q{Trying production: [NUMBER]},
621             Parse::RecDescent::_tracefirst($_[1]),
622             q{threadmember},
623             $tracelevel)
624             if defined $::RD_TRACE;
625 170         270 my $thisprod = $thisrule->{"prods"}[0];
626 170         262 $text = $_[1];
627 170         250 my $_savetext;
628 170         311 @item = (q{threadmember});
629 170         292 %item = (__RULE__ => q{threadmember});
630 170         238 my $repcount = 0;
631              
632              
633 170 50       312 Parse::RecDescent::_trace(q{Trying subrule: [NUMBER]},
634             Parse::RecDescent::_tracefirst($text),
635             q{threadmember},
636             $tracelevel)
637             if defined $::RD_TRACE;
638 1     1   8 if (1) { no strict qw{refs};
  1         3  
  1         354  
  170         218  
639 170         360 $expectation->is(q{})->at($text);
640 170 100   170   1438 unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::Thread::NUMBER($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
  170         300  
641             {
642            
643 84 50       155 Parse::RecDescent::_trace(q{<>},
644             Parse::RecDescent::_tracefirst($text),
645             q{threadmember},
646             $tracelevel)
647             if defined $::RD_TRACE;
648 84         223 $expectation->failed();
649 84         267 last;
650             }
651 86 50       306 Parse::RecDescent::_trace(q{>>Matched subrule: [NUMBER]<< (return value: [}
652             . $_tok . q{]},
653              
654             Parse::RecDescent::_tracefirst($text),
655             q{threadmember},
656             $tracelevel)
657             if defined $::RD_TRACE;
658 86         167 $item{q{NUMBER}} = $_tok;
659 86         151 push @item, $_tok;
660            
661             }
662              
663 86 50       161 Parse::RecDescent::_trace(q{Trying action},
664             Parse::RecDescent::_tracefirst($text),
665             q{threadmember},
666             $tracelevel)
667             if defined $::RD_TRACE;
668            
669              
670 86 50       151 $_tok = ($_noactions) ? 0 : do { $return = $item{NUMBER} ; };
  86         192  
671 86 50       169 unless (defined $_tok)
672             {
673 0 0       0 Parse::RecDescent::_trace(q{<> (return value: [undef])})
674             if defined $::RD_TRACE;
675 0         0 last;
676             }
677 86 50       187 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
678             . $_tok . q{])},
679             Parse::RecDescent::_tracefirst($text))
680             if defined $::RD_TRACE;
681 86         133 push @item, $_tok;
682 86         136 $item{__ACTION1__}=$_tok;
683            
684              
685 86 50       193 Parse::RecDescent::_trace(q{>>Matched production: [NUMBER]<<},
686             Parse::RecDescent::_tracefirst($text),
687             q{threadmember},
688             $tracelevel)
689             if defined $::RD_TRACE;
690              
691              
692              
693 86         128 $_matched = 1;
694 86         125 last;
695             }
696              
697              
698 170   66     530 while (!$_matched && !$commit)
699             {
700            
701 84 50       154 Parse::RecDescent::_trace(q{Trying production: [thread]},
702             Parse::RecDescent::_tracefirst($_[1]),
703             q{threadmember},
704             $tracelevel)
705             if defined $::RD_TRACE;
706 84         143 my $thisprod = $thisrule->{"prods"}[1];
707 84         137 $text = $_[1];
708 84         115 my $_savetext;
709 84         164 @item = (q{threadmember});
710 84         162 %item = (__RULE__ => q{threadmember});
711 84         124 my $repcount = 0;
712              
713              
714 84 50       165 Parse::RecDescent::_trace(q{Trying subrule: [thread]},
715             Parse::RecDescent::_tracefirst($text),
716             q{threadmember},
717             $tracelevel)
718             if defined $::RD_TRACE;
719 1     1   8 if (1) { no strict qw{refs};
  1         2  
  1         1092  
  84         101  
720 84         164 $expectation->is(q{})->at($text);
721 84 100   84   789 unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::Thread::thread($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
  84         143  
722             {
723            
724 66 50       118 Parse::RecDescent::_trace(q{<>},
725             Parse::RecDescent::_tracefirst($text),
726             q{threadmember},
727             $tracelevel)
728             if defined $::RD_TRACE;
729 66         166 $expectation->failed();
730 66         221 last;
731             }
732 18 50       53 Parse::RecDescent::_trace(q{>>Matched subrule: [thread]<< (return value: [}
733             . $_tok . q{]},
734              
735             Parse::RecDescent::_tracefirst($text),
736             q{threadmember},
737             $tracelevel)
738             if defined $::RD_TRACE;
739 18         33 $item{q{thread}} = $_tok;
740 18         30 push @item, $_tok;
741            
742             }
743              
744 18 50       37 Parse::RecDescent::_trace(q{Trying action},
745             Parse::RecDescent::_tracefirst($text),
746             q{threadmember},
747             $tracelevel)
748             if defined $::RD_TRACE;
749            
750              
751 18 50       31 $_tok = ($_noactions) ? 0 : do { $return = $item{thread} ; };
  18         30  
752 18 50       36 unless (defined $_tok)
753             {
754 0 0       0 Parse::RecDescent::_trace(q{<> (return value: [undef])})
755             if defined $::RD_TRACE;
756 0         0 last;
757             }
758 18 50       36 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
759             . $_tok . q{])},
760             Parse::RecDescent::_tracefirst($text))
761             if defined $::RD_TRACE;
762 18         28 push @item, $_tok;
763 18         23 $item{__ACTION1__}=$_tok;
764            
765              
766 18 50       35 Parse::RecDescent::_trace(q{>>Matched production: [thread]<<},
767             Parse::RecDescent::_tracefirst($text),
768             q{threadmember},
769             $tracelevel)
770             if defined $::RD_TRACE;
771              
772              
773              
774 18         18 $_matched = 1;
775 18         31 last;
776             }
777              
778              
779 170 100 66     535 unless ( $_matched || defined($score) )
780             {
781            
782              
783 66         104 $_[1] = $text; # NOT SURE THIS IS NEEDED
784 66 50       116 Parse::RecDescent::_trace(q{<>},
785             Parse::RecDescent::_tracefirst($_[1]),
786             q{threadmember},
787             $tracelevel)
788             if defined $::RD_TRACE;
789 66         249 return undef;
790             }
791 104 50 33     215 if (!defined($return) && defined($score))
792             {
793 0 0       0 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
794             q{threadmember},
795             $tracelevel)
796             if defined $::RD_TRACE;
797 0         0 $return = $score_return;
798             }
799 104         126 splice @{$thisparser->{errors}}, $err_at;
  104         180  
800 104 50       190 $return = $item[$#item] unless defined $return;
801 104 50       169 if (defined $::RD_TRACE)
802             {
803 0         0 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
804             $return . q{])}, "",
805             q{threadmember},
806             $tracelevel);
807 0         0 Parse::RecDescent::_trace(q{(consumed: [} .
808             Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
809             Parse::RecDescent::_tracefirst($text),
810             , q{threadmember},
811             $tracelevel)
812             }
813 104         179 $_[1] = $text;
814 104         461 return $return;
815             }
816             }
817 1     1 0 192 package Mail::IMAPClient::Thread; sub new { my $self = bless( {
818             '_AUTOACTION' => undef,
819             '_AUTOTREE' => undef,
820             '_check' => {
821             'itempos' => '',
822             'prevcolumn' => '',
823             'prevline' => '',
824             'prevoffset' => '',
825             'thiscolumn' => '',
826             'thisoffset' => ''
827             },
828             'localvars' => '',
829             'namespace' => 'Parse::RecDescent::Mail::IMAPClient::Thread',
830             'rules' => {
831             'NUMBER' => bless( {
832             'calls' => [],
833             'changed' => 0,
834             'impcount' => 0,
835             'line' => 1,
836             'name' => 'NUMBER',
837             'opcount' => 0,
838             'prods' => [
839             bless( {
840             'actcount' => 0,
841             'dircount' => 0,
842             'error' => undef,
843             'items' => [
844             bless( {
845             'description' => '/\\\\d+/',
846             'hashname' => '__PATTERN1__',
847             'ldelim' => '/',
848             'line' => 3,
849             'lookahead' => 0,
850             'mod' => '',
851             'pattern' => '\\d+',
852             'rdelim' => '/'
853             }, 'Parse::RecDescent::Token' )
854             ],
855             'line' => undef,
856             'number' => 0,
857             'patcount' => 1,
858             'strcount' => 0,
859             'uncommit' => undef
860             }, 'Parse::RecDescent::Production' )
861             ],
862             'vars' => ''
863             }, 'Parse::RecDescent::Rule' ),
864             'start' => bless( {
865             'calls' => [
866             'thread'
867             ],
868             'changed' => 0,
869             'impcount' => 0,
870             'line' => 15,
871             'name' => 'start',
872             'opcount' => 0,
873             'prods' => [
874             bless( {
875             'actcount' => 1,
876             'dircount' => 0,
877             'error' => undef,
878             'items' => [
879             bless( {
880             'description' => '/^\\\\* THREAD /i',
881             'hashname' => '__PATTERN1__',
882             'ldelim' => '/',
883             'line' => 16,
884             'lookahead' => 0,
885             'mod' => 'i',
886             'pattern' => '^\\* THREAD ',
887             'rdelim' => '/'
888             }, 'Parse::RecDescent::Token' ),
889             bless( {
890             'argcode' => undef,
891             'expected' => undef,
892             'line' => 16,
893             'lookahead' => 0,
894             'matchrule' => 0,
895             'max' => 100000000,
896             'min' => 0,
897             'repspec' => 's?',
898             'subrule' => 'thread'
899             }, 'Parse::RecDescent::Repetition' ),
900             bless( {
901             'code' => '{
902             $return=$item{\'thread(s?)\'}||undef;
903             }',
904             'hashname' => '__ACTION1__',
905             'line' => 16,
906             'lookahead' => 0
907             }, 'Parse::RecDescent::Action' )
908             ],
909             'line' => undef,
910             'number' => 0,
911             'patcount' => 1,
912             'strcount' => 0,
913             'uncommit' => undef
914             }, 'Parse::RecDescent::Production' )
915             ],
916             'vars' => ''
917             }, 'Parse::RecDescent::Rule' ),
918             'thread' => bless( {
919             'calls' => [
920             'threadmember'
921             ],
922             'changed' => 0,
923             'impcount' => 0,
924             'line' => 10,
925             'name' => 'thread',
926             'opcount' => 0,
927             'prods' => [
928             bless( {
929             'actcount' => 1,
930             'dircount' => 0,
931             'error' => undef,
932             'items' => [
933             bless( {
934             'description' => '\'(\'',
935             'hashname' => '__STRING1__',
936             'line' => 10,
937             'lookahead' => 0,
938             'pattern' => '('
939             }, 'Parse::RecDescent::InterpLit' ),
940             bless( {
941             'argcode' => undef,
942             'expected' => undef,
943             'line' => 10,
944             'lookahead' => 0,
945             'matchrule' => 0,
946             'max' => 100000000,
947             'min' => 1,
948             'repspec' => 's',
949             'subrule' => 'threadmember'
950             }, 'Parse::RecDescent::Repetition' ),
951             bless( {
952             'description' => '\')\'',
953             'hashname' => '__STRING2__',
954             'line' => 10,
955             'lookahead' => 0,
956             'pattern' => ')'
957             }, 'Parse::RecDescent::InterpLit' ),
958             bless( {
959             'code' => '{
960             $return = $item{\'threadmember(s)\'}||undef;
961             }',
962             'hashname' => '__ACTION1__',
963             'line' => 11,
964             'lookahead' => 0
965             }, 'Parse::RecDescent::Action' )
966             ],
967             'line' => undef,
968             'number' => 0,
969             'patcount' => 0,
970             'strcount' => 2,
971             'uncommit' => undef
972             }, 'Parse::RecDescent::Production' )
973             ],
974             'vars' => ''
975             }, 'Parse::RecDescent::Rule' ),
976             'threadmember' => bless( {
977             'calls' => [
978             'NUMBER',
979             'thread'
980             ],
981             'changed' => 0,
982             'impcount' => 0,
983             'line' => 5,
984             'name' => 'threadmember',
985             'opcount' => 0,
986             'prods' => [
987             bless( {
988             'actcount' => 1,
989             'dircount' => 0,
990             'error' => undef,
991             'items' => [
992             bless( {
993             'argcode' => undef,
994             'implicit' => undef,
995             'line' => 7,
996             'lookahead' => 0,
997             'matchrule' => 0,
998             'subrule' => 'NUMBER'
999             }, 'Parse::RecDescent::Subrule' ),
1000             bless( {
1001             'code' => '{ $return = $item{NUMBER} ; }',
1002             'hashname' => '__ACTION1__',
1003             'line' => 7,
1004             'lookahead' => 0
1005             }, 'Parse::RecDescent::Action' )
1006             ],
1007             'line' => undef,
1008             'number' => 0,
1009             'patcount' => 0,
1010             'strcount' => 0,
1011             'uncommit' => undef
1012             }, 'Parse::RecDescent::Production' ),
1013             bless( {
1014             'actcount' => 1,
1015             'dircount' => 0,
1016             'error' => undef,
1017             'items' => [
1018             bless( {
1019             'argcode' => undef,
1020             'implicit' => undef,
1021             'line' => 8,
1022             'lookahead' => 0,
1023             'matchrule' => 0,
1024             'subrule' => 'thread'
1025             }, 'Parse::RecDescent::Subrule' ),
1026             bless( {
1027             'code' => '{ $return = $item{thread} ; }',
1028             'hashname' => '__ACTION1__',
1029             'line' => 8,
1030             'lookahead' => 0
1031             }, 'Parse::RecDescent::Action' )
1032             ],
1033             'line' => 7,
1034             'number' => 1,
1035             'patcount' => 0,
1036             'strcount' => 0,
1037             'uncommit' => undef
1038             }, 'Parse::RecDescent::Production' )
1039             ],
1040             'vars' => ''
1041             }, 'Parse::RecDescent::Rule' )
1042             },
1043             'startcode' => ''
1044             }, 'Parse::RecDescent' );
1045             }