Subversion Repositories sysadmin_scripts

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
14 rodolico 1
package Mail::IMAPClient::BodyStructure::Parse;
2
use Parse::RecDescent;
3
 
4
{ my $ERRORS;
5
 
6
 
7
package Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse;
8
use strict;
9
use vars qw($skip $AUTOLOAD  );
10
@Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::ISA = ();
11
$skip = '\s*';
12
 
13
	my $subpartCount = 0;
14
	my $partCount    = 0;
15
;
16
 
17
 
18
{
19
local $SIG{__WARN__} = sub {0};
20
# PRETEND TO BE IN Parse::RecDescent NAMESPACE
21
*Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::AUTOLOAD	= sub
22
{
23
	no strict 'refs';
24
	$AUTOLOAD =~ s/^Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse/Parse::RecDescent/;
25
	goto &{$AUTOLOAD};
26
}
27
}
28
 
29
push @Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::ISA, 'Parse::RecDescent';
30
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
31
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyparms
32
{
33
	my $thisparser = $_[0];
34
	use vars q{$tracelevel};
35
	local $tracelevel = ($tracelevel||0)+1;
36
	$ERRORS = 0;
37
	my $thisrule = $thisparser->{"rules"}{"bodyparms"};
38
 
39
	Parse::RecDescent::_trace(q{Trying rule: [bodyparms]},
40
				  Parse::RecDescent::_tracefirst($_[1]),
41
				  q{bodyparms},
42
				  $tracelevel)
43
					if defined $::RD_TRACE;
44
 
45
	my $def_at = @{$thisparser->{deferred}};
46
	my $err_at = @{$thisparser->{errors}};
47
 
48
	my $score;
49
	my $score_return;
50
	my $_tok;
51
	my $return = undef;
52
	my $_matched=0;
53
	my $commit=0;
54
	my @item = ();
55
	my %item = ();
56
	my $repeating =  defined($_[2]) && $_[2];
57
	my $_noactions = defined($_[3]) && $_[3];
58
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
59
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
60
	my $text;
61
	my $lastsep="";
62
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or '('});
63
	$expectation->at($_[1]);
64
 
65
	my $thisline;
66
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
67
 
68
 
69
 
70
	while (!$_matched && !$commit)
71
	{
72
 
73
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
74
					  Parse::RecDescent::_tracefirst($_[1]),
75
					  q{bodyparms},
76
					  $tracelevel)
77
						if defined $::RD_TRACE;
78
		my $thisprod = $thisrule->{"prods"}[0];
79
		$text = $_[1];
80
		my $_savetext;
81
		@item = (q{bodyparms});
82
		%item = (__RULE__ => q{bodyparms});
83
		my $repcount = 0;
84
 
85
 
86
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
87
				  Parse::RecDescent::_tracefirst($text),
88
				  q{bodyparms},
89
				  $tracelevel)
90
					if defined $::RD_TRACE;
91
		if (1) { no strict qw{refs};
92
		$expectation->is(q{})->at($text);
93
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
94
		{
95
 
96
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
97
						  Parse::RecDescent::_tracefirst($text),
98
						  q{bodyparms},
99
						  $tracelevel)
100
							if defined $::RD_TRACE;
101
			$expectation->failed();
102
			last;
103
		}
104
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
105
					. $_tok . q{]},
106
 
107
					  Parse::RecDescent::_tracefirst($text),
108
					  q{bodyparms},
109
					  $tracelevel)
110
						if defined $::RD_TRACE;
111
		$item{q{NIL}} = $_tok;
112
		push @item, $_tok;
113
 
114
		}
115
 
116
 
117
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
118
					  Parse::RecDescent::_tracefirst($text),
119
					  q{bodyparms},
120
					  $tracelevel)
121
						if defined $::RD_TRACE;
122
		$_matched = 1;
123
		last;
124
	}
125
 
126
		splice
127
				@{$thisparser->{deferred}}, $def_at unless $_matched;
128
 
129
	while (!$_matched && !$commit)
130
	{
131
 
132
		Parse::RecDescent::_trace(q{Trying production: ['(' kvpair ')']},
133
					  Parse::RecDescent::_tracefirst($_[1]),
134
					  q{bodyparms},
135
					  $tracelevel)
136
						if defined $::RD_TRACE;
137
		my $thisprod = $thisrule->{"prods"}[1];
138
		$text = $_[1];
139
		my $_savetext;
140
		@item = (q{bodyparms});
141
		%item = (__RULE__ => q{bodyparms});
142
		my $repcount = 0;
143
 
144
 
145
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
146
					  Parse::RecDescent::_tracefirst($text),
147
					  q{bodyparms},
148
					  $tracelevel)
149
						if defined $::RD_TRACE;
150
		$lastsep = "";
151
		$expectation->is(q{})->at($text);
152
 
153
 
154
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A\(//)
155
		{
156
 
157
			$expectation->failed();
158
			Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
159
						  Parse::RecDescent::_tracefirst($text))
160
							if defined $::RD_TRACE;
161
			last;
162
		}
163
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
164
						. $& . q{])},
165
						  Parse::RecDescent::_tracefirst($text))
166
							if defined $::RD_TRACE;
167
		push @item, $item{__STRING1__}=$&;
168
 
169
 
170
		Parse::RecDescent::_trace(q{Trying repeated subrule: [kvpair]},
171
				  Parse::RecDescent::_tracefirst($text),
172
				  q{bodyparms},
173
				  $tracelevel)
174
					if defined $::RD_TRACE;
175
		$expectation->is(q{kvpair})->at($text);
176
 
177
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::kvpair, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
178
		{
179
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [kvpair]>>},
180
						  Parse::RecDescent::_tracefirst($text),
181
						  q{bodyparms},
182
						  $tracelevel)
183
							if defined $::RD_TRACE;
184
			last;
185
		}
186
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [kvpair]<< (}
187
					. @$_tok . q{ times)},
188
 
189
					  Parse::RecDescent::_tracefirst($text),
190
					  q{bodyparms},
191
					  $tracelevel)
192
						if defined $::RD_TRACE;
193
		$item{q{kvpair(s)}} = $_tok;
194
		push @item, $_tok;
195
 
196
 
197
 
198
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
199
					  Parse::RecDescent::_tracefirst($text),
200
					  q{bodyparms},
201
					  $tracelevel)
202
						if defined $::RD_TRACE;
203
		$lastsep = "";
204
		$expectation->is(q{')'})->at($text);
205
 
206
 
207
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A\)//)
208
		{
209
 
210
			$expectation->failed();
211
			Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
212
						  Parse::RecDescent::_tracefirst($text))
213
							if defined $::RD_TRACE;
214
			last;
215
		}
216
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
217
						. $& . q{])},
218
						  Parse::RecDescent::_tracefirst($text))
219
							if defined $::RD_TRACE;
220
		push @item, $item{__STRING2__}=$&;
221
 
222
 
223
		Parse::RecDescent::_trace(q{Trying action},
224
					  Parse::RecDescent::_tracefirst($text),
225
					  q{bodyparms},
226
					  $tracelevel)
227
						if defined $::RD_TRACE;
228
 
229
 
230
		$_tok = ($_noactions) ? 0 : do {
231
                          $return = $item{NIL} || 
232
                                    { map { (%$_) } @{$item{'kvpair(s)'}} };
233
                          $return || defined($return); 
234
                        };
235
		unless (defined $_tok)
236
		{
237
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
238
					if defined $::RD_TRACE;
239
			last;
240
		}
241
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
242
					  . $_tok . q{])},
243
					  Parse::RecDescent::_tracefirst($text))
244
						if defined $::RD_TRACE;
245
		push @item, $_tok;
246
		$item{__ACTION1__}=$_tok;
247
 
248
 
249
 
250
		Parse::RecDescent::_trace(q{>>Matched production: ['(' kvpair ')']<<},
251
					  Parse::RecDescent::_tracefirst($text),
252
					  q{bodyparms},
253
					  $tracelevel)
254
						if defined $::RD_TRACE;
255
		$_matched = 1;
256
		last;
257
	}
258
 
259
		splice
260
				@{$thisparser->{deferred}}, $def_at unless $_matched;
261
 
262
        unless ( $_matched || defined($score) )
263
	{
264
				splice @{$thisparser->{deferred}}, $def_at;
265
 
266
 
267
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
268
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
269
					 Parse::RecDescent::_tracefirst($_[1]),
270
					 q{bodyparms},
271
					 $tracelevel)
272
					if defined $::RD_TRACE;
273
		return undef;
274
	}
275
	if (!defined($return) && defined($score))
276
	{
277
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
278
					  q{bodyparms},
279
					  $tracelevel)
280
						if defined $::RD_TRACE;
281
		$return = $score_return;
282
	}
283
	splice @{$thisparser->{errors}}, $err_at;
284
	$return = $item[$#item] unless defined $return;
285
	if (defined $::RD_TRACE)
286
	{
287
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
288
					  $return . q{])}, "",
289
					  q{bodyparms},
290
					  $tracelevel);
291
		Parse::RecDescent::_trace(q{(consumed: [} .
292
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
293
					  Parse::RecDescent::_tracefirst($text),
294
					  , q{bodyparms},
295
					  $tracelevel)
296
	}
297
	$_[1] = $text;
298
	return $return;
299
}
300
 
301
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
302
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::date
303
{
304
	my $thisparser = $_[0];
305
	use vars q{$tracelevel};
306
	local $tracelevel = ($tracelevel||0)+1;
307
	$ERRORS = 0;
308
	my $thisrule = $thisparser->{"rules"}{"date"};
309
 
310
	Parse::RecDescent::_trace(q{Trying rule: [date]},
311
				  Parse::RecDescent::_tracefirst($_[1]),
312
				  q{date},
313
				  $tracelevel)
314
					if defined $::RD_TRACE;
315
 
316
	my $def_at = @{$thisparser->{deferred}};
317
	my $err_at = @{$thisparser->{errors}};
318
 
319
	my $score;
320
	my $score_return;
321
	my $_tok;
322
	my $return = undef;
323
	my $_matched=0;
324
	my $commit=0;
325
	my @item = ();
326
	my %item = ();
327
	my $repeating =  defined($_[2]) && $_[2];
328
	my $_noactions = defined($_[3]) && $_[3];
329
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
330
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
331
	my $text;
332
	my $lastsep="";
333
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or STRING});
334
	$expectation->at($_[1]);
335
 
336
	my $thisline;
337
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
338
 
339
 
340
 
341
	while (!$_matched && !$commit)
342
	{
343
 
344
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
345
					  Parse::RecDescent::_tracefirst($_[1]),
346
					  q{date},
347
					  $tracelevel)
348
						if defined $::RD_TRACE;
349
		my $thisprod = $thisrule->{"prods"}[0];
350
		$text = $_[1];
351
		my $_savetext;
352
		@item = (q{date});
353
		%item = (__RULE__ => q{date});
354
		my $repcount = 0;
355
 
356
 
357
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
358
				  Parse::RecDescent::_tracefirst($text),
359
				  q{date},
360
				  $tracelevel)
361
					if defined $::RD_TRACE;
362
		if (1) { no strict qw{refs};
363
		$expectation->is(q{})->at($text);
364
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
365
		{
366
 
367
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
368
						  Parse::RecDescent::_tracefirst($text),
369
						  q{date},
370
						  $tracelevel)
371
							if defined $::RD_TRACE;
372
			$expectation->failed();
373
			last;
374
		}
375
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
376
					. $_tok . q{]},
377
 
378
					  Parse::RecDescent::_tracefirst($text),
379
					  q{date},
380
					  $tracelevel)
381
						if defined $::RD_TRACE;
382
		$item{q{NIL}} = $_tok;
383
		push @item, $_tok;
384
 
385
		}
386
 
387
 
388
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
389
					  Parse::RecDescent::_tracefirst($text),
390
					  q{date},
391
					  $tracelevel)
392
						if defined $::RD_TRACE;
393
		$_matched = 1;
394
		last;
395
	}
396
 
397
		splice
398
				@{$thisparser->{deferred}}, $def_at unless $_matched;
399
 
400
	while (!$_matched && !$commit)
401
	{
402
 
403
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
404
					  Parse::RecDescent::_tracefirst($_[1]),
405
					  q{date},
406
					  $tracelevel)
407
						if defined $::RD_TRACE;
408
		my $thisprod = $thisrule->{"prods"}[1];
409
		$text = $_[1];
410
		my $_savetext;
411
		@item = (q{date});
412
		%item = (__RULE__ => q{date});
413
		my $repcount = 0;
414
 
415
 
416
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
417
				  Parse::RecDescent::_tracefirst($text),
418
				  q{date},
419
				  $tracelevel)
420
					if defined $::RD_TRACE;
421
		if (1) { no strict qw{refs};
422
		$expectation->is(q{})->at($text);
423
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
424
		{
425
 
426
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
427
						  Parse::RecDescent::_tracefirst($text),
428
						  q{date},
429
						  $tracelevel)
430
							if defined $::RD_TRACE;
431
			$expectation->failed();
432
			last;
433
		}
434
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
435
					. $_tok . q{]},
436
 
437
					  Parse::RecDescent::_tracefirst($text),
438
					  q{date},
439
					  $tracelevel)
440
						if defined $::RD_TRACE;
441
		$item{q{STRING}} = $_tok;
442
		push @item, $_tok;
443
 
444
		}
445
 
446
		Parse::RecDescent::_trace(q{Trying action},
447
					  Parse::RecDescent::_tracefirst($text),
448
					  q{date},
449
					  $tracelevel)
450
						if defined $::RD_TRACE;
451
 
452
 
453
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{STRING} ;$return||defined($return);};
454
		unless (defined $_tok)
455
		{
456
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
457
					if defined $::RD_TRACE;
458
			last;
459
		}
460
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
461
					  . $_tok . q{])},
462
					  Parse::RecDescent::_tracefirst($text))
463
						if defined $::RD_TRACE;
464
		push @item, $_tok;
465
		$item{__ACTION1__}=$_tok;
466
 
467
 
468
 
469
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
470
					  Parse::RecDescent::_tracefirst($text),
471
					  q{date},
472
					  $tracelevel)
473
						if defined $::RD_TRACE;
474
		$_matched = 1;
475
		last;
476
	}
477
 
478
		splice
479
				@{$thisparser->{deferred}}, $def_at unless $_matched;
480
 
481
        unless ( $_matched || defined($score) )
482
	{
483
				splice @{$thisparser->{deferred}}, $def_at;
484
 
485
 
486
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
487
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
488
					 Parse::RecDescent::_tracefirst($_[1]),
489
					 q{date},
490
					 $tracelevel)
491
					if defined $::RD_TRACE;
492
		return undef;
493
	}
494
	if (!defined($return) && defined($score))
495
	{
496
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
497
					  q{date},
498
					  $tracelevel)
499
						if defined $::RD_TRACE;
500
		$return = $score_return;
501
	}
502
	splice @{$thisparser->{errors}}, $err_at;
503
	$return = $item[$#item] unless defined $return;
504
	if (defined $::RD_TRACE)
505
	{
506
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
507
					  $return . q{])}, "",
508
					  q{date},
509
					  $tracelevel);
510
		Parse::RecDescent::_trace(q{(consumed: [} .
511
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
512
					  Parse::RecDescent::_tracefirst($text),
513
					  , q{date},
514
					  $tracelevel)
515
	}
516
	$_[1] = $text;
517
	return $return;
518
}
519
 
520
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
521
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodysubtype
522
{
523
	my $thisparser = $_[0];
524
	use vars q{$tracelevel};
525
	local $tracelevel = ($tracelevel||0)+1;
526
	$ERRORS = 0;
527
	my $thisrule = $thisparser->{"rules"}{"bodysubtype"};
528
 
529
	Parse::RecDescent::_trace(q{Trying rule: [bodysubtype]},
530
				  Parse::RecDescent::_tracefirst($_[1]),
531
				  q{bodysubtype},
532
				  $tracelevel)
533
					if defined $::RD_TRACE;
534
 
535
	my $def_at = @{$thisparser->{deferred}};
536
	my $err_at = @{$thisparser->{errors}};
537
 
538
	my $score;
539
	my $score_return;
540
	my $_tok;
541
	my $return = undef;
542
	my $_matched=0;
543
	my $commit=0;
544
	my @item = ();
545
	my %item = ();
546
	my $repeating =  defined($_[2]) && $_[2];
547
	my $_noactions = defined($_[3]) && $_[3];
548
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
549
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
550
	my $text;
551
	my $lastsep="";
552
    my $expectation = new Parse::RecDescent::Expectation(q{PLAIN, or HTML, or NIL, or STRING});
553
	$expectation->at($_[1]);
554
 
555
	my $thisline;
556
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
557
 
558
 
559
 
560
	while (!$_matched && !$commit)
561
	{
562
 
563
		Parse::RecDescent::_trace(q{Trying production: [PLAIN]},
564
					  Parse::RecDescent::_tracefirst($_[1]),
565
					  q{bodysubtype},
566
					  $tracelevel)
567
						if defined $::RD_TRACE;
568
		my $thisprod = $thisrule->{"prods"}[0];
569
		$text = $_[1];
570
		my $_savetext;
571
		@item = (q{bodysubtype});
572
		%item = (__RULE__ => q{bodysubtype});
573
		my $repcount = 0;
574
 
575
 
576
		Parse::RecDescent::_trace(q{Trying subrule: [PLAIN]},
577
				  Parse::RecDescent::_tracefirst($text),
578
				  q{bodysubtype},
579
				  $tracelevel)
580
					if defined $::RD_TRACE;
581
		if (1) { no strict qw{refs};
582
		$expectation->is(q{})->at($text);
583
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::PLAIN($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
584
		{
585
 
586
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [PLAIN]>>},
587
						  Parse::RecDescent::_tracefirst($text),
588
						  q{bodysubtype},
589
						  $tracelevel)
590
							if defined $::RD_TRACE;
591
			$expectation->failed();
592
			last;
593
		}
594
		Parse::RecDescent::_trace(q{>>Matched subrule: [PLAIN]<< (return value: [}
595
					. $_tok . q{]},
596
 
597
					  Parse::RecDescent::_tracefirst($text),
598
					  q{bodysubtype},
599
					  $tracelevel)
600
						if defined $::RD_TRACE;
601
		$item{q{PLAIN}} = $_tok;
602
		push @item, $_tok;
603
 
604
		}
605
 
606
 
607
		Parse::RecDescent::_trace(q{>>Matched production: [PLAIN]<<},
608
					  Parse::RecDescent::_tracefirst($text),
609
					  q{bodysubtype},
610
					  $tracelevel)
611
						if defined $::RD_TRACE;
612
		$_matched = 1;
613
		last;
614
	}
615
 
616
		splice
617
				@{$thisparser->{deferred}}, $def_at unless $_matched;
618
 
619
	while (!$_matched && !$commit)
620
	{
621
 
622
		Parse::RecDescent::_trace(q{Trying production: [HTML]},
623
					  Parse::RecDescent::_tracefirst($_[1]),
624
					  q{bodysubtype},
625
					  $tracelevel)
626
						if defined $::RD_TRACE;
627
		my $thisprod = $thisrule->{"prods"}[1];
628
		$text = $_[1];
629
		my $_savetext;
630
		@item = (q{bodysubtype});
631
		%item = (__RULE__ => q{bodysubtype});
632
		my $repcount = 0;
633
 
634
 
635
		Parse::RecDescent::_trace(q{Trying subrule: [HTML]},
636
				  Parse::RecDescent::_tracefirst($text),
637
				  q{bodysubtype},
638
				  $tracelevel)
639
					if defined $::RD_TRACE;
640
		if (1) { no strict qw{refs};
641
		$expectation->is(q{})->at($text);
642
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::HTML($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
643
		{
644
 
645
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [HTML]>>},
646
						  Parse::RecDescent::_tracefirst($text),
647
						  q{bodysubtype},
648
						  $tracelevel)
649
							if defined $::RD_TRACE;
650
			$expectation->failed();
651
			last;
652
		}
653
		Parse::RecDescent::_trace(q{>>Matched subrule: [HTML]<< (return value: [}
654
					. $_tok . q{]},
655
 
656
					  Parse::RecDescent::_tracefirst($text),
657
					  q{bodysubtype},
658
					  $tracelevel)
659
						if defined $::RD_TRACE;
660
		$item{q{HTML}} = $_tok;
661
		push @item, $_tok;
662
 
663
		}
664
 
665
 
666
		Parse::RecDescent::_trace(q{>>Matched production: [HTML]<<},
667
					  Parse::RecDescent::_tracefirst($text),
668
					  q{bodysubtype},
669
					  $tracelevel)
670
						if defined $::RD_TRACE;
671
		$_matched = 1;
672
		last;
673
	}
674
 
675
		splice
676
				@{$thisparser->{deferred}}, $def_at unless $_matched;
677
 
678
	while (!$_matched && !$commit)
679
	{
680
 
681
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
682
					  Parse::RecDescent::_tracefirst($_[1]),
683
					  q{bodysubtype},
684
					  $tracelevel)
685
						if defined $::RD_TRACE;
686
		my $thisprod = $thisrule->{"prods"}[2];
687
		$text = $_[1];
688
		my $_savetext;
689
		@item = (q{bodysubtype});
690
		%item = (__RULE__ => q{bodysubtype});
691
		my $repcount = 0;
692
 
693
 
694
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
695
				  Parse::RecDescent::_tracefirst($text),
696
				  q{bodysubtype},
697
				  $tracelevel)
698
					if defined $::RD_TRACE;
699
		if (1) { no strict qw{refs};
700
		$expectation->is(q{})->at($text);
701
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
702
		{
703
 
704
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
705
						  Parse::RecDescent::_tracefirst($text),
706
						  q{bodysubtype},
707
						  $tracelevel)
708
							if defined $::RD_TRACE;
709
			$expectation->failed();
710
			last;
711
		}
712
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
713
					. $_tok . q{]},
714
 
715
					  Parse::RecDescent::_tracefirst($text),
716
					  q{bodysubtype},
717
					  $tracelevel)
718
						if defined $::RD_TRACE;
719
		$item{q{NIL}} = $_tok;
720
		push @item, $_tok;
721
 
722
		}
723
 
724
 
725
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
726
					  Parse::RecDescent::_tracefirst($text),
727
					  q{bodysubtype},
728
					  $tracelevel)
729
						if defined $::RD_TRACE;
730
		$_matched = 1;
731
		last;
732
	}
733
 
734
		splice
735
				@{$thisparser->{deferred}}, $def_at unless $_matched;
736
 
737
	while (!$_matched && !$commit)
738
	{
739
 
740
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
741
					  Parse::RecDescent::_tracefirst($_[1]),
742
					  q{bodysubtype},
743
					  $tracelevel)
744
						if defined $::RD_TRACE;
745
		my $thisprod = $thisrule->{"prods"}[3];
746
		$text = $_[1];
747
		my $_savetext;
748
		@item = (q{bodysubtype});
749
		%item = (__RULE__ => q{bodysubtype});
750
		my $repcount = 0;
751
 
752
 
753
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
754
				  Parse::RecDescent::_tracefirst($text),
755
				  q{bodysubtype},
756
				  $tracelevel)
757
					if defined $::RD_TRACE;
758
		if (1) { no strict qw{refs};
759
		$expectation->is(q{})->at($text);
760
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
761
		{
762
 
763
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
764
						  Parse::RecDescent::_tracefirst($text),
765
						  q{bodysubtype},
766
						  $tracelevel)
767
							if defined $::RD_TRACE;
768
			$expectation->failed();
769
			last;
770
		}
771
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
772
					. $_tok . q{]},
773
 
774
					  Parse::RecDescent::_tracefirst($text),
775
					  q{bodysubtype},
776
					  $tracelevel)
777
						if defined $::RD_TRACE;
778
		$item{q{STRING}} = $_tok;
779
		push @item, $_tok;
780
 
781
		}
782
 
783
		Parse::RecDescent::_trace(q{Trying action},
784
					  Parse::RecDescent::_tracefirst($text),
785
					  q{bodysubtype},
786
					  $tracelevel)
787
						if defined $::RD_TRACE;
788
 
789
 
790
		$_tok = ($_noactions) ? 0 : do { $return = $item{PLAIN}||$item{HTML}||$item{NIL}||$item{STRING} ; 
791
		  $return||defined($return);
792
		};
793
		unless (defined $_tok)
794
		{
795
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
796
					if defined $::RD_TRACE;
797
			last;
798
		}
799
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
800
					  . $_tok . q{])},
801
					  Parse::RecDescent::_tracefirst($text))
802
						if defined $::RD_TRACE;
803
		push @item, $_tok;
804
		$item{__ACTION1__}=$_tok;
805
 
806
 
807
 
808
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
809
					  Parse::RecDescent::_tracefirst($text),
810
					  q{bodysubtype},
811
					  $tracelevel)
812
						if defined $::RD_TRACE;
813
		$_matched = 1;
814
		last;
815
	}
816
 
817
		splice
818
				@{$thisparser->{deferred}}, $def_at unless $_matched;
819
 
820
        unless ( $_matched || defined($score) )
821
	{
822
				splice @{$thisparser->{deferred}}, $def_at;
823
 
824
 
825
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
826
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
827
					 Parse::RecDescent::_tracefirst($_[1]),
828
					 q{bodysubtype},
829
					 $tracelevel)
830
					if defined $::RD_TRACE;
831
		return undef;
832
	}
833
	if (!defined($return) && defined($score))
834
	{
835
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
836
					  q{bodysubtype},
837
					  $tracelevel)
838
						if defined $::RD_TRACE;
839
		$return = $score_return;
840
	}
841
	splice @{$thisparser->{errors}}, $err_at;
842
	$return = $item[$#item] unless defined $return;
843
	if (defined $::RD_TRACE)
844
	{
845
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
846
					  $return . q{])}, "",
847
					  q{bodysubtype},
848
					  $tracelevel);
849
		Parse::RecDescent::_trace(q{(consumed: [} .
850
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
851
					  Parse::RecDescent::_tracefirst($text),
852
					  , q{bodysubtype},
853
					  $tracelevel)
854
	}
855
	$_[1] = $text;
856
	return $return;
857
}
858
 
859
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
860
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::hostname
861
{
862
	my $thisparser = $_[0];
863
	use vars q{$tracelevel};
864
	local $tracelevel = ($tracelevel||0)+1;
865
	$ERRORS = 0;
866
	my $thisrule = $thisparser->{"rules"}{"hostname"};
867
 
868
	Parse::RecDescent::_trace(q{Trying rule: [hostname]},
869
				  Parse::RecDescent::_tracefirst($_[1]),
870
				  q{hostname},
871
				  $tracelevel)
872
					if defined $::RD_TRACE;
873
 
874
	my $def_at = @{$thisparser->{deferred}};
875
	my $err_at = @{$thisparser->{errors}};
876
 
877
	my $score;
878
	my $score_return;
879
	my $_tok;
880
	my $return = undef;
881
	my $_matched=0;
882
	my $commit=0;
883
	my @item = ();
884
	my %item = ();
885
	my $repeating =  defined($_[2]) && $_[2];
886
	my $_noactions = defined($_[3]) && $_[3];
887
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
888
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
889
	my $text;
890
	my $lastsep="";
891
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or STRING});
892
	$expectation->at($_[1]);
893
 
894
	my $thisline;
895
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
896
 
897
 
898
 
899
	while (!$_matched && !$commit)
900
	{
901
 
902
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
903
					  Parse::RecDescent::_tracefirst($_[1]),
904
					  q{hostname},
905
					  $tracelevel)
906
						if defined $::RD_TRACE;
907
		my $thisprod = $thisrule->{"prods"}[0];
908
		$text = $_[1];
909
		my $_savetext;
910
		@item = (q{hostname});
911
		%item = (__RULE__ => q{hostname});
912
		my $repcount = 0;
913
 
914
 
915
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
916
				  Parse::RecDescent::_tracefirst($text),
917
				  q{hostname},
918
				  $tracelevel)
919
					if defined $::RD_TRACE;
920
		if (1) { no strict qw{refs};
921
		$expectation->is(q{})->at($text);
922
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
923
		{
924
 
925
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
926
						  Parse::RecDescent::_tracefirst($text),
927
						  q{hostname},
928
						  $tracelevel)
929
							if defined $::RD_TRACE;
930
			$expectation->failed();
931
			last;
932
		}
933
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
934
					. $_tok . q{]},
935
 
936
					  Parse::RecDescent::_tracefirst($text),
937
					  q{hostname},
938
					  $tracelevel)
939
						if defined $::RD_TRACE;
940
		$item{q{NIL}} = $_tok;
941
		push @item, $_tok;
942
 
943
		}
944
 
945
 
946
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
947
					  Parse::RecDescent::_tracefirst($text),
948
					  q{hostname},
949
					  $tracelevel)
950
						if defined $::RD_TRACE;
951
		$_matched = 1;
952
		last;
953
	}
954
 
955
		splice
956
				@{$thisparser->{deferred}}, $def_at unless $_matched;
957
 
958
	while (!$_matched && !$commit)
959
	{
960
 
961
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
962
					  Parse::RecDescent::_tracefirst($_[1]),
963
					  q{hostname},
964
					  $tracelevel)
965
						if defined $::RD_TRACE;
966
		my $thisprod = $thisrule->{"prods"}[1];
967
		$text = $_[1];
968
		my $_savetext;
969
		@item = (q{hostname});
970
		%item = (__RULE__ => q{hostname});
971
		my $repcount = 0;
972
 
973
 
974
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
975
				  Parse::RecDescent::_tracefirst($text),
976
				  q{hostname},
977
				  $tracelevel)
978
					if defined $::RD_TRACE;
979
		if (1) { no strict qw{refs};
980
		$expectation->is(q{})->at($text);
981
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
982
		{
983
 
984
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
985
						  Parse::RecDescent::_tracefirst($text),
986
						  q{hostname},
987
						  $tracelevel)
988
							if defined $::RD_TRACE;
989
			$expectation->failed();
990
			last;
991
		}
992
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
993
					. $_tok . q{]},
994
 
995
					  Parse::RecDescent::_tracefirst($text),
996
					  q{hostname},
997
					  $tracelevel)
998
						if defined $::RD_TRACE;
999
		$item{q{STRING}} = $_tok;
1000
		push @item, $_tok;
1001
 
1002
		}
1003
 
1004
		Parse::RecDescent::_trace(q{Trying action},
1005
					  Parse::RecDescent::_tracefirst($text),
1006
					  q{hostname},
1007
					  $tracelevel)
1008
						if defined $::RD_TRACE;
1009
 
1010
 
1011
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{STRING} ;$return||defined($return);};
1012
		unless (defined $_tok)
1013
		{
1014
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
1015
					if defined $::RD_TRACE;
1016
			last;
1017
		}
1018
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1019
					  . $_tok . q{])},
1020
					  Parse::RecDescent::_tracefirst($text))
1021
						if defined $::RD_TRACE;
1022
		push @item, $_tok;
1023
		$item{__ACTION1__}=$_tok;
1024
 
1025
 
1026
 
1027
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
1028
					  Parse::RecDescent::_tracefirst($text),
1029
					  q{hostname},
1030
					  $tracelevel)
1031
						if defined $::RD_TRACE;
1032
		$_matched = 1;
1033
		last;
1034
	}
1035
 
1036
		splice
1037
				@{$thisparser->{deferred}}, $def_at unless $_matched;
1038
 
1039
        unless ( $_matched || defined($score) )
1040
	{
1041
				splice @{$thisparser->{deferred}}, $def_at;
1042
 
1043
 
1044
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
1045
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
1046
					 Parse::RecDescent::_tracefirst($_[1]),
1047
					 q{hostname},
1048
					 $tracelevel)
1049
					if defined $::RD_TRACE;
1050
		return undef;
1051
	}
1052
	if (!defined($return) && defined($score))
1053
	{
1054
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1055
					  q{hostname},
1056
					  $tracelevel)
1057
						if defined $::RD_TRACE;
1058
		$return = $score_return;
1059
	}
1060
	splice @{$thisparser->{errors}}, $err_at;
1061
	$return = $item[$#item] unless defined $return;
1062
	if (defined $::RD_TRACE)
1063
	{
1064
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1065
					  $return . q{])}, "",
1066
					  q{hostname},
1067
					  $tracelevel);
1068
		Parse::RecDescent::_trace(q{(consumed: [} .
1069
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
1070
					  Parse::RecDescent::_tracefirst($text),
1071
					  , q{hostname},
1072
					  $tracelevel)
1073
	}
1074
	$_[1] = $text;
1075
	return $return;
1076
}
1077
 
1078
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1079
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::basicfields
1080
{
1081
	my $thisparser = $_[0];
1082
	use vars q{$tracelevel};
1083
	local $tracelevel = ($tracelevel||0)+1;
1084
	$ERRORS = 0;
1085
	my $thisrule = $thisparser->{"rules"}{"basicfields"};
1086
 
1087
	Parse::RecDescent::_trace(q{Trying rule: [basicfields]},
1088
				  Parse::RecDescent::_tracefirst($_[1]),
1089
				  q{basicfields},
1090
				  $tracelevel)
1091
					if defined $::RD_TRACE;
1092
 
1093
	my $def_at = @{$thisparser->{deferred}};
1094
	my $err_at = @{$thisparser->{errors}};
1095
 
1096
	my $score;
1097
	my $score_return;
1098
	my $_tok;
1099
	my $return = undef;
1100
	my $_matched=0;
1101
	my $commit=0;
1102
	my @item = ();
1103
	my %item = ();
1104
	my $repeating =  defined($_[2]) && $_[2];
1105
	my $_noactions = defined($_[3]) && $_[3];
1106
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
1107
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
1108
	my $text;
1109
	my $lastsep="";
1110
    my $expectation = new Parse::RecDescent::Expectation(q{bodysubtype});
1111
	$expectation->at($_[1]);
1112
 
1113
	my $thisline;
1114
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1115
 
1116
 
1117
 
1118
	while (!$_matched && !$commit)
1119
	{
1120
 
1121
		Parse::RecDescent::_trace(q{Trying production: [bodysubtype bodyparms bodyid bodydesc bodyenc bodysize]},
1122
					  Parse::RecDescent::_tracefirst($_[1]),
1123
					  q{basicfields},
1124
					  $tracelevel)
1125
						if defined $::RD_TRACE;
1126
		my $thisprod = $thisrule->{"prods"}[0];
1127
		$text = $_[1];
1128
		my $_savetext;
1129
		@item = (q{basicfields});
1130
		%item = (__RULE__ => q{basicfields});
1131
		my $repcount = 0;
1132
 
1133
 
1134
		Parse::RecDescent::_trace(q{Trying subrule: [bodysubtype]},
1135
				  Parse::RecDescent::_tracefirst($text),
1136
				  q{basicfields},
1137
				  $tracelevel)
1138
					if defined $::RD_TRACE;
1139
		if (1) { no strict qw{refs};
1140
		$expectation->is(q{})->at($text);
1141
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodysubtype($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1142
		{
1143
 
1144
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [bodysubtype]>>},
1145
						  Parse::RecDescent::_tracefirst($text),
1146
						  q{basicfields},
1147
						  $tracelevel)
1148
							if defined $::RD_TRACE;
1149
			$expectation->failed();
1150
			last;
1151
		}
1152
		Parse::RecDescent::_trace(q{>>Matched subrule: [bodysubtype]<< (return value: [}
1153
					. $_tok . q{]},
1154
 
1155
					  Parse::RecDescent::_tracefirst($text),
1156
					  q{basicfields},
1157
					  $tracelevel)
1158
						if defined $::RD_TRACE;
1159
		$item{q{bodysubtype}} = $_tok;
1160
		push @item, $_tok;
1161
 
1162
		}
1163
 
1164
		Parse::RecDescent::_trace(q{Trying subrule: [bodyparms]},
1165
				  Parse::RecDescent::_tracefirst($text),
1166
				  q{basicfields},
1167
				  $tracelevel)
1168
					if defined $::RD_TRACE;
1169
		if (1) { no strict qw{refs};
1170
		$expectation->is(q{bodyparms})->at($text);
1171
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyparms($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1172
		{
1173
 
1174
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [bodyparms]>>},
1175
						  Parse::RecDescent::_tracefirst($text),
1176
						  q{basicfields},
1177
						  $tracelevel)
1178
							if defined $::RD_TRACE;
1179
			$expectation->failed();
1180
			last;
1181
		}
1182
		Parse::RecDescent::_trace(q{>>Matched subrule: [bodyparms]<< (return value: [}
1183
					. $_tok . q{]},
1184
 
1185
					  Parse::RecDescent::_tracefirst($text),
1186
					  q{basicfields},
1187
					  $tracelevel)
1188
						if defined $::RD_TRACE;
1189
		$item{q{bodyparms}} = $_tok;
1190
		push @item, $_tok;
1191
 
1192
		}
1193
 
1194
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodyid]},
1195
				  Parse::RecDescent::_tracefirst($text),
1196
				  q{basicfields},
1197
				  $tracelevel)
1198
					if defined $::RD_TRACE;
1199
		$expectation->is(q{bodyid})->at($text);
1200
 
1201
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyid, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
1202
		{
1203
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodyid]>>},
1204
						  Parse::RecDescent::_tracefirst($text),
1205
						  q{basicfields},
1206
						  $tracelevel)
1207
							if defined $::RD_TRACE;
1208
			last;
1209
		}
1210
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodyid]<< (}
1211
					. @$_tok . q{ times)},
1212
 
1213
					  Parse::RecDescent::_tracefirst($text),
1214
					  q{basicfields},
1215
					  $tracelevel)
1216
						if defined $::RD_TRACE;
1217
		$item{q{bodyid(?)}} = $_tok;
1218
		push @item, $_tok;
1219
 
1220
 
1221
 
1222
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodydesc]},
1223
				  Parse::RecDescent::_tracefirst($text),
1224
				  q{basicfields},
1225
				  $tracelevel)
1226
					if defined $::RD_TRACE;
1227
		$expectation->is(q{bodydesc})->at($text);
1228
 
1229
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodydesc, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
1230
		{
1231
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodydesc]>>},
1232
						  Parse::RecDescent::_tracefirst($text),
1233
						  q{basicfields},
1234
						  $tracelevel)
1235
							if defined $::RD_TRACE;
1236
			last;
1237
		}
1238
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodydesc]<< (}
1239
					. @$_tok . q{ times)},
1240
 
1241
					  Parse::RecDescent::_tracefirst($text),
1242
					  q{basicfields},
1243
					  $tracelevel)
1244
						if defined $::RD_TRACE;
1245
		$item{q{bodydesc(?)}} = $_tok;
1246
		push @item, $_tok;
1247
 
1248
 
1249
 
1250
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodyenc]},
1251
				  Parse::RecDescent::_tracefirst($text),
1252
				  q{basicfields},
1253
				  $tracelevel)
1254
					if defined $::RD_TRACE;
1255
		$expectation->is(q{bodyenc})->at($text);
1256
 
1257
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyenc, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
1258
		{
1259
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodyenc]>>},
1260
						  Parse::RecDescent::_tracefirst($text),
1261
						  q{basicfields},
1262
						  $tracelevel)
1263
							if defined $::RD_TRACE;
1264
			last;
1265
		}
1266
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodyenc]<< (}
1267
					. @$_tok . q{ times)},
1268
 
1269
					  Parse::RecDescent::_tracefirst($text),
1270
					  q{basicfields},
1271
					  $tracelevel)
1272
						if defined $::RD_TRACE;
1273
		$item{q{bodyenc(?)}} = $_tok;
1274
		push @item, $_tok;
1275
 
1276
 
1277
 
1278
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodysize]},
1279
				  Parse::RecDescent::_tracefirst($text),
1280
				  q{basicfields},
1281
				  $tracelevel)
1282
					if defined $::RD_TRACE;
1283
		$expectation->is(q{bodysize})->at($text);
1284
 
1285
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodysize, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
1286
		{
1287
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodysize]>>},
1288
						  Parse::RecDescent::_tracefirst($text),
1289
						  q{basicfields},
1290
						  $tracelevel)
1291
							if defined $::RD_TRACE;
1292
			last;
1293
		}
1294
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodysize]<< (}
1295
					. @$_tok . q{ times)},
1296
 
1297
					  Parse::RecDescent::_tracefirst($text),
1298
					  q{basicfields},
1299
					  $tracelevel)
1300
						if defined $::RD_TRACE;
1301
		$item{q{bodysize(?)}} = $_tok;
1302
		push @item, $_tok;
1303
 
1304
 
1305
 
1306
		Parse::RecDescent::_trace(q{Trying action},
1307
					  Parse::RecDescent::_tracefirst($text),
1308
					  q{basicfields},
1309
					  $tracelevel)
1310
						if defined $::RD_TRACE;
1311
 
1312
 
1313
		$_tok = ($_noactions) ? 0 : do { 
1314
 
1315
	$return = { 
1316
		bodysubtype 	=> 	    $item{bodysubtype} ,
1317
 
1318
		bodyparms 	=> 	    $item{bodyparms} ,
1319
 
1320
		bodyid 		=> (ref     $item{'bodyid(?)'}	?
1321
					    $item{'bodyid(?)'}[0]	:
1322
					    $item{'bodyid(?)'} ),
1323
 
1324
		'bodydesc' 	=> (ref     $item{'bodydesc(?)'}	?
1325
					    $item{'bodydesc(?)'}[0]	:
1326
					    $item{'bodydesc(?)'} ),
1327
 
1328
		'bodyenc' 	=> (ref     $item{'bodyenc(?)'}	?
1329
					    $item{'bodyenc(?)'}[0]	:
1330
					    $item{'bodyenc(?)'} ),
1331
 
1332
		'bodysize' 	=> (ref     $item{'bodysize(?)'}	?
1333
					    $item{'bodysize(?)'}[0]	:
1334
					    $item{'bodysize(?)'} ),
1335
	};
1336
	$return;
1337
};
1338
		unless (defined $_tok)
1339
		{
1340
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
1341
					if defined $::RD_TRACE;
1342
			last;
1343
		}
1344
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1345
					  . $_tok . q{])},
1346
					  Parse::RecDescent::_tracefirst($text))
1347
						if defined $::RD_TRACE;
1348
		push @item, $_tok;
1349
		$item{__ACTION1__}=$_tok;
1350
 
1351
 
1352
 
1353
		Parse::RecDescent::_trace(q{>>Matched production: [bodysubtype bodyparms bodyid bodydesc bodyenc bodysize]<<},
1354
					  Parse::RecDescent::_tracefirst($text),
1355
					  q{basicfields},
1356
					  $tracelevel)
1357
						if defined $::RD_TRACE;
1358
		$_matched = 1;
1359
		last;
1360
	}
1361
 
1362
		splice
1363
				@{$thisparser->{deferred}}, $def_at unless $_matched;
1364
 
1365
        unless ( $_matched || defined($score) )
1366
	{
1367
				splice @{$thisparser->{deferred}}, $def_at;
1368
 
1369
 
1370
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
1371
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
1372
					 Parse::RecDescent::_tracefirst($_[1]),
1373
					 q{basicfields},
1374
					 $tracelevel)
1375
					if defined $::RD_TRACE;
1376
		return undef;
1377
	}
1378
	if (!defined($return) && defined($score))
1379
	{
1380
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1381
					  q{basicfields},
1382
					  $tracelevel)
1383
						if defined $::RD_TRACE;
1384
		$return = $score_return;
1385
	}
1386
	splice @{$thisparser->{errors}}, $err_at;
1387
	$return = $item[$#item] unless defined $return;
1388
	if (defined $::RD_TRACE)
1389
	{
1390
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1391
					  $return . q{])}, "",
1392
					  q{basicfields},
1393
					  $tracelevel);
1394
		Parse::RecDescent::_trace(q{(consumed: [} .
1395
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
1396
					  Parse::RecDescent::_tracefirst($text),
1397
					  , q{basicfields},
1398
					  $tracelevel)
1399
	}
1400
	$_[1] = $text;
1401
	return $return;
1402
}
1403
 
1404
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1405
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::personalname
1406
{
1407
	my $thisparser = $_[0];
1408
	use vars q{$tracelevel};
1409
	local $tracelevel = ($tracelevel||0)+1;
1410
	$ERRORS = 0;
1411
	my $thisrule = $thisparser->{"rules"}{"personalname"};
1412
 
1413
	Parse::RecDescent::_trace(q{Trying rule: [personalname]},
1414
				  Parse::RecDescent::_tracefirst($_[1]),
1415
				  q{personalname},
1416
				  $tracelevel)
1417
					if defined $::RD_TRACE;
1418
 
1419
	my $def_at = @{$thisparser->{deferred}};
1420
	my $err_at = @{$thisparser->{errors}};
1421
 
1422
	my $score;
1423
	my $score_return;
1424
	my $_tok;
1425
	my $return = undef;
1426
	my $_matched=0;
1427
	my $commit=0;
1428
	my @item = ();
1429
	my %item = ();
1430
	my $repeating =  defined($_[2]) && $_[2];
1431
	my $_noactions = defined($_[3]) && $_[3];
1432
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
1433
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
1434
	my $text;
1435
	my $lastsep="";
1436
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or STRING});
1437
	$expectation->at($_[1]);
1438
 
1439
	my $thisline;
1440
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1441
 
1442
 
1443
 
1444
	while (!$_matched && !$commit)
1445
	{
1446
 
1447
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
1448
					  Parse::RecDescent::_tracefirst($_[1]),
1449
					  q{personalname},
1450
					  $tracelevel)
1451
						if defined $::RD_TRACE;
1452
		my $thisprod = $thisrule->{"prods"}[0];
1453
		$text = $_[1];
1454
		my $_savetext;
1455
		@item = (q{personalname});
1456
		%item = (__RULE__ => q{personalname});
1457
		my $repcount = 0;
1458
 
1459
 
1460
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
1461
				  Parse::RecDescent::_tracefirst($text),
1462
				  q{personalname},
1463
				  $tracelevel)
1464
					if defined $::RD_TRACE;
1465
		if (1) { no strict qw{refs};
1466
		$expectation->is(q{})->at($text);
1467
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1468
		{
1469
 
1470
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
1471
						  Parse::RecDescent::_tracefirst($text),
1472
						  q{personalname},
1473
						  $tracelevel)
1474
							if defined $::RD_TRACE;
1475
			$expectation->failed();
1476
			last;
1477
		}
1478
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
1479
					. $_tok . q{]},
1480
 
1481
					  Parse::RecDescent::_tracefirst($text),
1482
					  q{personalname},
1483
					  $tracelevel)
1484
						if defined $::RD_TRACE;
1485
		$item{q{NIL}} = $_tok;
1486
		push @item, $_tok;
1487
 
1488
		}
1489
 
1490
 
1491
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
1492
					  Parse::RecDescent::_tracefirst($text),
1493
					  q{personalname},
1494
					  $tracelevel)
1495
						if defined $::RD_TRACE;
1496
		$_matched = 1;
1497
		last;
1498
	}
1499
 
1500
		splice
1501
				@{$thisparser->{deferred}}, $def_at unless $_matched;
1502
 
1503
	while (!$_matched && !$commit)
1504
	{
1505
 
1506
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
1507
					  Parse::RecDescent::_tracefirst($_[1]),
1508
					  q{personalname},
1509
					  $tracelevel)
1510
						if defined $::RD_TRACE;
1511
		my $thisprod = $thisrule->{"prods"}[1];
1512
		$text = $_[1];
1513
		my $_savetext;
1514
		@item = (q{personalname});
1515
		%item = (__RULE__ => q{personalname});
1516
		my $repcount = 0;
1517
 
1518
 
1519
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
1520
				  Parse::RecDescent::_tracefirst($text),
1521
				  q{personalname},
1522
				  $tracelevel)
1523
					if defined $::RD_TRACE;
1524
		if (1) { no strict qw{refs};
1525
		$expectation->is(q{})->at($text);
1526
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1527
		{
1528
 
1529
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
1530
						  Parse::RecDescent::_tracefirst($text),
1531
						  q{personalname},
1532
						  $tracelevel)
1533
							if defined $::RD_TRACE;
1534
			$expectation->failed();
1535
			last;
1536
		}
1537
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
1538
					. $_tok . q{]},
1539
 
1540
					  Parse::RecDescent::_tracefirst($text),
1541
					  q{personalname},
1542
					  $tracelevel)
1543
						if defined $::RD_TRACE;
1544
		$item{q{STRING}} = $_tok;
1545
		push @item, $_tok;
1546
 
1547
		}
1548
 
1549
		Parse::RecDescent::_trace(q{Trying action},
1550
					  Parse::RecDescent::_tracefirst($text),
1551
					  q{personalname},
1552
					  $tracelevel)
1553
						if defined $::RD_TRACE;
1554
 
1555
 
1556
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{STRING} ;$return||defined($return);};
1557
		unless (defined $_tok)
1558
		{
1559
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
1560
					if defined $::RD_TRACE;
1561
			last;
1562
		}
1563
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1564
					  . $_tok . q{])},
1565
					  Parse::RecDescent::_tracefirst($text))
1566
						if defined $::RD_TRACE;
1567
		push @item, $_tok;
1568
		$item{__ACTION1__}=$_tok;
1569
 
1570
 
1571
 
1572
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
1573
					  Parse::RecDescent::_tracefirst($text),
1574
					  q{personalname},
1575
					  $tracelevel)
1576
						if defined $::RD_TRACE;
1577
		$_matched = 1;
1578
		last;
1579
	}
1580
 
1581
		splice
1582
				@{$thisparser->{deferred}}, $def_at unless $_matched;
1583
 
1584
        unless ( $_matched || defined($score) )
1585
	{
1586
				splice @{$thisparser->{deferred}}, $def_at;
1587
 
1588
 
1589
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
1590
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
1591
					 Parse::RecDescent::_tracefirst($_[1]),
1592
					 q{personalname},
1593
					 $tracelevel)
1594
					if defined $::RD_TRACE;
1595
		return undef;
1596
	}
1597
	if (!defined($return) && defined($score))
1598
	{
1599
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1600
					  q{personalname},
1601
					  $tracelevel)
1602
						if defined $::RD_TRACE;
1603
		$return = $score_return;
1604
	}
1605
	splice @{$thisparser->{errors}}, $err_at;
1606
	$return = $item[$#item] unless defined $return;
1607
	if (defined $::RD_TRACE)
1608
	{
1609
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1610
					  $return . q{])}, "",
1611
					  q{personalname},
1612
					  $tracelevel);
1613
		Parse::RecDescent::_trace(q{(consumed: [} .
1614
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
1615
					  Parse::RecDescent::_tracefirst($text),
1616
					  , q{personalname},
1617
					  $tracelevel)
1618
	}
1619
	$_[1] = $text;
1620
	return $return;
1621
}
1622
 
1623
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1624
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::key
1625
{
1626
	my $thisparser = $_[0];
1627
	use vars q{$tracelevel};
1628
	local $tracelevel = ($tracelevel||0)+1;
1629
	$ERRORS = 0;
1630
	my $thisrule = $thisparser->{"rules"}{"key"};
1631
 
1632
	Parse::RecDescent::_trace(q{Trying rule: [key]},
1633
				  Parse::RecDescent::_tracefirst($_[1]),
1634
				  q{key},
1635
				  $tracelevel)
1636
					if defined $::RD_TRACE;
1637
 
1638
	my $def_at = @{$thisparser->{deferred}};
1639
	my $err_at = @{$thisparser->{errors}};
1640
 
1641
	my $score;
1642
	my $score_return;
1643
	my $_tok;
1644
	my $return = undef;
1645
	my $_matched=0;
1646
	my $commit=0;
1647
	my @item = ();
1648
	my %item = ();
1649
	my $repeating =  defined($_[2]) && $_[2];
1650
	my $_noactions = defined($_[3]) && $_[3];
1651
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
1652
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
1653
	my $text;
1654
	my $lastsep="";
1655
    my $expectation = new Parse::RecDescent::Expectation(q{STRING});
1656
	$expectation->at($_[1]);
1657
 
1658
	my $thisline;
1659
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1660
 
1661
 
1662
 
1663
	while (!$_matched && !$commit)
1664
	{
1665
 
1666
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
1667
					  Parse::RecDescent::_tracefirst($_[1]),
1668
					  q{key},
1669
					  $tracelevel)
1670
						if defined $::RD_TRACE;
1671
		my $thisprod = $thisrule->{"prods"}[0];
1672
		$text = $_[1];
1673
		my $_savetext;
1674
		@item = (q{key});
1675
		%item = (__RULE__ => q{key});
1676
		my $repcount = 0;
1677
 
1678
 
1679
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
1680
				  Parse::RecDescent::_tracefirst($text),
1681
				  q{key},
1682
				  $tracelevel)
1683
					if defined $::RD_TRACE;
1684
		if (1) { no strict qw{refs};
1685
		$expectation->is(q{})->at($text);
1686
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1687
		{
1688
 
1689
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
1690
						  Parse::RecDescent::_tracefirst($text),
1691
						  q{key},
1692
						  $tracelevel)
1693
							if defined $::RD_TRACE;
1694
			$expectation->failed();
1695
			last;
1696
		}
1697
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
1698
					. $_tok . q{]},
1699
 
1700
					  Parse::RecDescent::_tracefirst($text),
1701
					  q{key},
1702
					  $tracelevel)
1703
						if defined $::RD_TRACE;
1704
		$item{q{STRING}} = $_tok;
1705
		push @item, $_tok;
1706
 
1707
		}
1708
 
1709
		Parse::RecDescent::_trace(q{Trying action},
1710
					  Parse::RecDescent::_tracefirst($text),
1711
					  q{key},
1712
					  $tracelevel)
1713
						if defined $::RD_TRACE;
1714
 
1715
 
1716
		$_tok = ($_noactions) ? 0 : do { $return = $item{STRING} ; $return||defined($return);};
1717
		unless (defined $_tok)
1718
		{
1719
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
1720
					if defined $::RD_TRACE;
1721
			last;
1722
		}
1723
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1724
					  . $_tok . q{])},
1725
					  Parse::RecDescent::_tracefirst($text))
1726
						if defined $::RD_TRACE;
1727
		push @item, $_tok;
1728
		$item{__ACTION1__}=$_tok;
1729
 
1730
 
1731
 
1732
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
1733
					  Parse::RecDescent::_tracefirst($text),
1734
					  q{key},
1735
					  $tracelevel)
1736
						if defined $::RD_TRACE;
1737
		$_matched = 1;
1738
		last;
1739
	}
1740
 
1741
		splice
1742
				@{$thisparser->{deferred}}, $def_at unless $_matched;
1743
 
1744
        unless ( $_matched || defined($score) )
1745
	{
1746
				splice @{$thisparser->{deferred}}, $def_at;
1747
 
1748
 
1749
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
1750
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
1751
					 Parse::RecDescent::_tracefirst($_[1]),
1752
					 q{key},
1753
					 $tracelevel)
1754
					if defined $::RD_TRACE;
1755
		return undef;
1756
	}
1757
	if (!defined($return) && defined($score))
1758
	{
1759
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1760
					  q{key},
1761
					  $tracelevel)
1762
						if defined $::RD_TRACE;
1763
		$return = $score_return;
1764
	}
1765
	splice @{$thisparser->{errors}}, $err_at;
1766
	$return = $item[$#item] unless defined $return;
1767
	if (defined $::RD_TRACE)
1768
	{
1769
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1770
					  $return . q{])}, "",
1771
					  q{key},
1772
					  $tracelevel);
1773
		Parse::RecDescent::_trace(q{(consumed: [} .
1774
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
1775
					  Parse::RecDescent::_tracefirst($text),
1776
					  , q{key},
1777
					  $tracelevel)
1778
	}
1779
	$_[1] = $text;
1780
	return $return;
1781
}
1782
 
1783
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1784
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::cc
1785
{
1786
	my $thisparser = $_[0];
1787
	use vars q{$tracelevel};
1788
	local $tracelevel = ($tracelevel||0)+1;
1789
	$ERRORS = 0;
1790
	my $thisrule = $thisparser->{"rules"}{"cc"};
1791
 
1792
	Parse::RecDescent::_trace(q{Trying rule: [cc]},
1793
				  Parse::RecDescent::_tracefirst($_[1]),
1794
				  q{cc},
1795
				  $tracelevel)
1796
					if defined $::RD_TRACE;
1797
 
1798
	my $def_at = @{$thisparser->{deferred}};
1799
	my $err_at = @{$thisparser->{errors}};
1800
 
1801
	my $score;
1802
	my $score_return;
1803
	my $_tok;
1804
	my $return = undef;
1805
	my $_matched=0;
1806
	my $commit=0;
1807
	my @item = ();
1808
	my %item = ();
1809
	my $repeating =  defined($_[2]) && $_[2];
1810
	my $_noactions = defined($_[3]) && $_[3];
1811
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
1812
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
1813
	my $text;
1814
	my $lastsep="";
1815
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or '('});
1816
	$expectation->at($_[1]);
1817
 
1818
	my $thisline;
1819
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1820
 
1821
 
1822
 
1823
	while (!$_matched && !$commit)
1824
	{
1825
 
1826
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
1827
					  Parse::RecDescent::_tracefirst($_[1]),
1828
					  q{cc},
1829
					  $tracelevel)
1830
						if defined $::RD_TRACE;
1831
		my $thisprod = $thisrule->{"prods"}[0];
1832
		$text = $_[1];
1833
		my $_savetext;
1834
		@item = (q{cc});
1835
		%item = (__RULE__ => q{cc});
1836
		my $repcount = 0;
1837
 
1838
 
1839
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
1840
				  Parse::RecDescent::_tracefirst($text),
1841
				  q{cc},
1842
				  $tracelevel)
1843
					if defined $::RD_TRACE;
1844
		if (1) { no strict qw{refs};
1845
		$expectation->is(q{})->at($text);
1846
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1847
		{
1848
 
1849
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
1850
						  Parse::RecDescent::_tracefirst($text),
1851
						  q{cc},
1852
						  $tracelevel)
1853
							if defined $::RD_TRACE;
1854
			$expectation->failed();
1855
			last;
1856
		}
1857
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
1858
					. $_tok . q{]},
1859
 
1860
					  Parse::RecDescent::_tracefirst($text),
1861
					  q{cc},
1862
					  $tracelevel)
1863
						if defined $::RD_TRACE;
1864
		$item{q{NIL}} = $_tok;
1865
		push @item, $_tok;
1866
 
1867
		}
1868
 
1869
 
1870
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
1871
					  Parse::RecDescent::_tracefirst($text),
1872
					  q{cc},
1873
					  $tracelevel)
1874
						if defined $::RD_TRACE;
1875
		$_matched = 1;
1876
		last;
1877
	}
1878
 
1879
		splice
1880
				@{$thisparser->{deferred}}, $def_at unless $_matched;
1881
 
1882
	while (!$_matched && !$commit)
1883
	{
1884
 
1885
		Parse::RecDescent::_trace(q{Trying production: ['(' addressstruct ')']},
1886
					  Parse::RecDescent::_tracefirst($_[1]),
1887
					  q{cc},
1888
					  $tracelevel)
1889
						if defined $::RD_TRACE;
1890
		my $thisprod = $thisrule->{"prods"}[1];
1891
		$text = $_[1];
1892
		my $_savetext;
1893
		@item = (q{cc});
1894
		%item = (__RULE__ => q{cc});
1895
		my $repcount = 0;
1896
 
1897
 
1898
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
1899
					  Parse::RecDescent::_tracefirst($text),
1900
					  q{cc},
1901
					  $tracelevel)
1902
						if defined $::RD_TRACE;
1903
		$lastsep = "";
1904
		$expectation->is(q{})->at($text);
1905
 
1906
 
1907
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "("; 1 } and
1908
		     substr($text,0,length($_tok)) eq $_tok and
1909
		     do { substr($text,0,length($_tok)) = ""; 1; }
1910
		)
1911
		{
1912
 
1913
			$expectation->failed();
1914
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
1915
						  Parse::RecDescent::_tracefirst($text))
1916
							if defined $::RD_TRACE;
1917
			last;
1918
		}
1919
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1920
						. $_tok . q{])},
1921
						  Parse::RecDescent::_tracefirst($text))
1922
							if defined $::RD_TRACE;
1923
		push @item, $item{__STRING1__}=$_tok;
1924
 
1925
 
1926
		Parse::RecDescent::_trace(q{Trying repeated subrule: [addressstruct]},
1927
				  Parse::RecDescent::_tracefirst($text),
1928
				  q{cc},
1929
				  $tracelevel)
1930
					if defined $::RD_TRACE;
1931
		$expectation->is(q{addressstruct})->at($text);
1932
 
1933
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::addressstruct, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
1934
		{
1935
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [addressstruct]>>},
1936
						  Parse::RecDescent::_tracefirst($text),
1937
						  q{cc},
1938
						  $tracelevel)
1939
							if defined $::RD_TRACE;
1940
			last;
1941
		}
1942
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [addressstruct]<< (}
1943
					. @$_tok . q{ times)},
1944
 
1945
					  Parse::RecDescent::_tracefirst($text),
1946
					  q{cc},
1947
					  $tracelevel)
1948
						if defined $::RD_TRACE;
1949
		$item{q{addressstruct(s)}} = $_tok;
1950
		push @item, $_tok;
1951
 
1952
 
1953
 
1954
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
1955
					  Parse::RecDescent::_tracefirst($text),
1956
					  q{cc},
1957
					  $tracelevel)
1958
						if defined $::RD_TRACE;
1959
		$lastsep = "";
1960
		$expectation->is(q{')'})->at($text);
1961
 
1962
 
1963
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
1964
		     substr($text,0,length($_tok)) eq $_tok and
1965
		     do { substr($text,0,length($_tok)) = ""; 1; }
1966
		)
1967
		{
1968
 
1969
			$expectation->failed();
1970
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
1971
						  Parse::RecDescent::_tracefirst($text))
1972
							if defined $::RD_TRACE;
1973
			last;
1974
		}
1975
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1976
						. $_tok . q{])},
1977
						  Parse::RecDescent::_tracefirst($text))
1978
							if defined $::RD_TRACE;
1979
		push @item, $item{__STRING2__}=$_tok;
1980
 
1981
 
1982
		Parse::RecDescent::_trace(q{Trying action},
1983
					  Parse::RecDescent::_tracefirst($text),
1984
					  q{cc},
1985
					  $tracelevel)
1986
						if defined $::RD_TRACE;
1987
 
1988
 
1989
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{'addressstruct(s)'} };
1990
		unless (defined $_tok)
1991
		{
1992
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
1993
					if defined $::RD_TRACE;
1994
			last;
1995
		}
1996
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1997
					  . $_tok . q{])},
1998
					  Parse::RecDescent::_tracefirst($text))
1999
						if defined $::RD_TRACE;
2000
		push @item, $_tok;
2001
		$item{__ACTION1__}=$_tok;
2002
 
2003
 
2004
 
2005
		Parse::RecDescent::_trace(q{>>Matched production: ['(' addressstruct ')']<<},
2006
					  Parse::RecDescent::_tracefirst($text),
2007
					  q{cc},
2008
					  $tracelevel)
2009
						if defined $::RD_TRACE;
2010
		$_matched = 1;
2011
		last;
2012
	}
2013
 
2014
		splice
2015
				@{$thisparser->{deferred}}, $def_at unless $_matched;
2016
 
2017
        unless ( $_matched || defined($score) )
2018
	{
2019
				splice @{$thisparser->{deferred}}, $def_at;
2020
 
2021
 
2022
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
2023
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
2024
					 Parse::RecDescent::_tracefirst($_[1]),
2025
					 q{cc},
2026
					 $tracelevel)
2027
					if defined $::RD_TRACE;
2028
		return undef;
2029
	}
2030
	if (!defined($return) && defined($score))
2031
	{
2032
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2033
					  q{cc},
2034
					  $tracelevel)
2035
						if defined $::RD_TRACE;
2036
		$return = $score_return;
2037
	}
2038
	splice @{$thisparser->{errors}}, $err_at;
2039
	$return = $item[$#item] unless defined $return;
2040
	if (defined $::RD_TRACE)
2041
	{
2042
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2043
					  $return . q{])}, "",
2044
					  q{cc},
2045
					  $tracelevel);
2046
		Parse::RecDescent::_trace(q{(consumed: [} .
2047
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
2048
					  Parse::RecDescent::_tracefirst($text),
2049
					  , q{cc},
2050
					  $tracelevel)
2051
	}
2052
	$_[1] = $text;
2053
	return $return;
2054
}
2055
 
2056
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2057
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyMD5
2058
{
2059
	my $thisparser = $_[0];
2060
	use vars q{$tracelevel};
2061
	local $tracelevel = ($tracelevel||0)+1;
2062
	$ERRORS = 0;
2063
	my $thisrule = $thisparser->{"rules"}{"bodyMD5"};
2064
 
2065
	Parse::RecDescent::_trace(q{Trying rule: [bodyMD5]},
2066
				  Parse::RecDescent::_tracefirst($_[1]),
2067
				  q{bodyMD5},
2068
				  $tracelevel)
2069
					if defined $::RD_TRACE;
2070
 
2071
	my $def_at = @{$thisparser->{deferred}};
2072
	my $err_at = @{$thisparser->{errors}};
2073
 
2074
	my $score;
2075
	my $score_return;
2076
	my $_tok;
2077
	my $return = undef;
2078
	my $_matched=0;
2079
	my $commit=0;
2080
	my @item = ();
2081
	my %item = ();
2082
	my $repeating =  defined($_[2]) && $_[2];
2083
	my $_noactions = defined($_[3]) && $_[3];
2084
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
2085
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
2086
	my $text;
2087
	my $lastsep="";
2088
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or STRING});
2089
	$expectation->at($_[1]);
2090
 
2091
	my $thisline;
2092
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2093
 
2094
 
2095
 
2096
	while (!$_matched && !$commit)
2097
	{
2098
 
2099
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
2100
					  Parse::RecDescent::_tracefirst($_[1]),
2101
					  q{bodyMD5},
2102
					  $tracelevel)
2103
						if defined $::RD_TRACE;
2104
		my $thisprod = $thisrule->{"prods"}[0];
2105
		$text = $_[1];
2106
		my $_savetext;
2107
		@item = (q{bodyMD5});
2108
		%item = (__RULE__ => q{bodyMD5});
2109
		my $repcount = 0;
2110
 
2111
 
2112
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
2113
				  Parse::RecDescent::_tracefirst($text),
2114
				  q{bodyMD5},
2115
				  $tracelevel)
2116
					if defined $::RD_TRACE;
2117
		if (1) { no strict qw{refs};
2118
		$expectation->is(q{})->at($text);
2119
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2120
		{
2121
 
2122
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
2123
						  Parse::RecDescent::_tracefirst($text),
2124
						  q{bodyMD5},
2125
						  $tracelevel)
2126
							if defined $::RD_TRACE;
2127
			$expectation->failed();
2128
			last;
2129
		}
2130
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
2131
					. $_tok . q{]},
2132
 
2133
					  Parse::RecDescent::_tracefirst($text),
2134
					  q{bodyMD5},
2135
					  $tracelevel)
2136
						if defined $::RD_TRACE;
2137
		$item{q{NIL}} = $_tok;
2138
		push @item, $_tok;
2139
 
2140
		}
2141
 
2142
 
2143
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
2144
					  Parse::RecDescent::_tracefirst($text),
2145
					  q{bodyMD5},
2146
					  $tracelevel)
2147
						if defined $::RD_TRACE;
2148
		$_matched = 1;
2149
		last;
2150
	}
2151
 
2152
		splice
2153
				@{$thisparser->{deferred}}, $def_at unless $_matched;
2154
 
2155
	while (!$_matched && !$commit)
2156
	{
2157
 
2158
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
2159
					  Parse::RecDescent::_tracefirst($_[1]),
2160
					  q{bodyMD5},
2161
					  $tracelevel)
2162
						if defined $::RD_TRACE;
2163
		my $thisprod = $thisrule->{"prods"}[1];
2164
		$text = $_[1];
2165
		my $_savetext;
2166
		@item = (q{bodyMD5});
2167
		%item = (__RULE__ => q{bodyMD5});
2168
		my $repcount = 0;
2169
 
2170
 
2171
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
2172
				  Parse::RecDescent::_tracefirst($text),
2173
				  q{bodyMD5},
2174
				  $tracelevel)
2175
					if defined $::RD_TRACE;
2176
		if (1) { no strict qw{refs};
2177
		$expectation->is(q{})->at($text);
2178
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2179
		{
2180
 
2181
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
2182
						  Parse::RecDescent::_tracefirst($text),
2183
						  q{bodyMD5},
2184
						  $tracelevel)
2185
							if defined $::RD_TRACE;
2186
			$expectation->failed();
2187
			last;
2188
		}
2189
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
2190
					. $_tok . q{]},
2191
 
2192
					  Parse::RecDescent::_tracefirst($text),
2193
					  q{bodyMD5},
2194
					  $tracelevel)
2195
						if defined $::RD_TRACE;
2196
		$item{q{STRING}} = $_tok;
2197
		push @item, $_tok;
2198
 
2199
		}
2200
 
2201
		Parse::RecDescent::_trace(q{Trying action},
2202
					  Parse::RecDescent::_tracefirst($text),
2203
					  q{bodyMD5},
2204
					  $tracelevel)
2205
						if defined $::RD_TRACE;
2206
 
2207
 
2208
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{STRING} ;$return||defined($return);};
2209
		unless (defined $_tok)
2210
		{
2211
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
2212
					if defined $::RD_TRACE;
2213
			last;
2214
		}
2215
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2216
					  . $_tok . q{])},
2217
					  Parse::RecDescent::_tracefirst($text))
2218
						if defined $::RD_TRACE;
2219
		push @item, $_tok;
2220
		$item{__ACTION1__}=$_tok;
2221
 
2222
 
2223
 
2224
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
2225
					  Parse::RecDescent::_tracefirst($text),
2226
					  q{bodyMD5},
2227
					  $tracelevel)
2228
						if defined $::RD_TRACE;
2229
		$_matched = 1;
2230
		last;
2231
	}
2232
 
2233
		splice
2234
				@{$thisparser->{deferred}}, $def_at unless $_matched;
2235
 
2236
        unless ( $_matched || defined($score) )
2237
	{
2238
				splice @{$thisparser->{deferred}}, $def_at;
2239
 
2240
 
2241
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
2242
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
2243
					 Parse::RecDescent::_tracefirst($_[1]),
2244
					 q{bodyMD5},
2245
					 $tracelevel)
2246
					if defined $::RD_TRACE;
2247
		return undef;
2248
	}
2249
	if (!defined($return) && defined($score))
2250
	{
2251
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2252
					  q{bodyMD5},
2253
					  $tracelevel)
2254
						if defined $::RD_TRACE;
2255
		$return = $score_return;
2256
	}
2257
	splice @{$thisparser->{errors}}, $err_at;
2258
	$return = $item[$#item] unless defined $return;
2259
	if (defined $::RD_TRACE)
2260
	{
2261
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2262
					  $return . q{])}, "",
2263
					  q{bodyMD5},
2264
					  $tracelevel);
2265
		Parse::RecDescent::_trace(q{(consumed: [} .
2266
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
2267
					  Parse::RecDescent::_tracefirst($text),
2268
					  , q{bodyMD5},
2269
					  $tracelevel)
2270
	}
2271
	$_[1] = $text;
2272
	return $return;
2273
}
2274
 
2275
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2276
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::envelope
2277
{
2278
	my $thisparser = $_[0];
2279
	use vars q{$tracelevel};
2280
	local $tracelevel = ($tracelevel||0)+1;
2281
	$ERRORS = 0;
2282
	my $thisrule = $thisparser->{"rules"}{"envelope"};
2283
 
2284
	Parse::RecDescent::_trace(q{Trying rule: [envelope]},
2285
				  Parse::RecDescent::_tracefirst($_[1]),
2286
				  q{envelope},
2287
				  $tracelevel)
2288
					if defined $::RD_TRACE;
2289
 
2290
	my $def_at = @{$thisparser->{deferred}};
2291
	my $err_at = @{$thisparser->{errors}};
2292
 
2293
	my $score;
2294
	my $score_return;
2295
	my $_tok;
2296
	my $return = undef;
2297
	my $_matched=0;
2298
	my $commit=0;
2299
	my @item = ();
2300
	my %item = ();
2301
	my $repeating =  defined($_[2]) && $_[2];
2302
	my $_noactions = defined($_[3]) && $_[3];
2303
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
2304
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
2305
	my $text;
2306
	my $lastsep="";
2307
    my $expectation = new Parse::RecDescent::Expectation(q{/.*\\(.*ENVELOPE/});
2308
	$expectation->at($_[1]);
2309
 
2310
	my $thisline;
2311
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2312
 
2313
 
2314
 
2315
	while (!$_matched && !$commit)
2316
	{
2317
 
2318
		Parse::RecDescent::_trace(q{Trying production: [/.*\\(.*ENVELOPE/ envelopestruct /.*\\)/]},
2319
					  Parse::RecDescent::_tracefirst($_[1]),
2320
					  q{envelope},
2321
					  $tracelevel)
2322
						if defined $::RD_TRACE;
2323
		my $thisprod = $thisrule->{"prods"}[0];
2324
		$text = $_[1];
2325
		my $_savetext;
2326
		@item = (q{envelope});
2327
		%item = (__RULE__ => q{envelope});
2328
		my $repcount = 0;
2329
 
2330
 
2331
		Parse::RecDescent::_trace(q{Trying terminal: [/.*\\(.*ENVELOPE/]}, Parse::RecDescent::_tracefirst($text),
2332
					  q{envelope},
2333
					  $tracelevel)
2334
						if defined $::RD_TRACE;
2335
		$lastsep = "";
2336
		$expectation->is(q{})->at($text);
2337
 
2338
 
2339
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:.*\(.*ENVELOPE)//)
2340
		{
2341
 
2342
			$expectation->failed();
2343
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
2344
						  Parse::RecDescent::_tracefirst($text))
2345
					if defined $::RD_TRACE;
2346
 
2347
			last;
2348
		}
2349
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2350
						. $& . q{])},
2351
						  Parse::RecDescent::_tracefirst($text))
2352
					if defined $::RD_TRACE;
2353
		push @item, $item{__PATTERN1__}=$&;
2354
 
2355
 
2356
		Parse::RecDescent::_trace(q{Trying subrule: [envelopestruct]},
2357
				  Parse::RecDescent::_tracefirst($text),
2358
				  q{envelope},
2359
				  $tracelevel)
2360
					if defined $::RD_TRACE;
2361
		if (1) { no strict qw{refs};
2362
		$expectation->is(q{envelopestruct})->at($text);
2363
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::envelopestruct($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2364
		{
2365
 
2366
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [envelopestruct]>>},
2367
						  Parse::RecDescent::_tracefirst($text),
2368
						  q{envelope},
2369
						  $tracelevel)
2370
							if defined $::RD_TRACE;
2371
			$expectation->failed();
2372
			last;
2373
		}
2374
		Parse::RecDescent::_trace(q{>>Matched subrule: [envelopestruct]<< (return value: [}
2375
					. $_tok . q{]},
2376
 
2377
					  Parse::RecDescent::_tracefirst($text),
2378
					  q{envelope},
2379
					  $tracelevel)
2380
						if defined $::RD_TRACE;
2381
		$item{q{envelopestruct}} = $_tok;
2382
		push @item, $_tok;
2383
 
2384
		}
2385
 
2386
		Parse::RecDescent::_trace(q{Trying terminal: [/.*\\)/]}, Parse::RecDescent::_tracefirst($text),
2387
					  q{envelope},
2388
					  $tracelevel)
2389
						if defined $::RD_TRACE;
2390
		$lastsep = "";
2391
		$expectation->is(q{/.*\\)/})->at($text);
2392
 
2393
 
2394
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:.*\))//)
2395
		{
2396
 
2397
			$expectation->failed();
2398
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
2399
						  Parse::RecDescent::_tracefirst($text))
2400
					if defined $::RD_TRACE;
2401
 
2402
			last;
2403
		}
2404
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2405
						. $& . q{])},
2406
						  Parse::RecDescent::_tracefirst($text))
2407
					if defined $::RD_TRACE;
2408
		push @item, $item{__PATTERN2__}=$&;
2409
 
2410
 
2411
		Parse::RecDescent::_trace(q{Trying action},
2412
					  Parse::RecDescent::_tracefirst($text),
2413
					  q{envelope},
2414
					  $tracelevel)
2415
						if defined $::RD_TRACE;
2416
 
2417
 
2418
		$_tok = ($_noactions) ? 0 : do {
2419
		$return = $item{envelopestruct} ;
2420
		$return||defined($return) ;
2421
		};
2422
		unless (defined $_tok)
2423
		{
2424
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
2425
					if defined $::RD_TRACE;
2426
			last;
2427
		}
2428
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2429
					  . $_tok . q{])},
2430
					  Parse::RecDescent::_tracefirst($text))
2431
						if defined $::RD_TRACE;
2432
		push @item, $_tok;
2433
		$item{__ACTION1__}=$_tok;
2434
 
2435
 
2436
 
2437
		Parse::RecDescent::_trace(q{>>Matched production: [/.*\\(.*ENVELOPE/ envelopestruct /.*\\)/]<<},
2438
					  Parse::RecDescent::_tracefirst($text),
2439
					  q{envelope},
2440
					  $tracelevel)
2441
						if defined $::RD_TRACE;
2442
		$_matched = 1;
2443
		last;
2444
	}
2445
 
2446
		splice
2447
				@{$thisparser->{deferred}}, $def_at unless $_matched;
2448
 
2449
        unless ( $_matched || defined($score) )
2450
	{
2451
				splice @{$thisparser->{deferred}}, $def_at;
2452
 
2453
 
2454
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
2455
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
2456
					 Parse::RecDescent::_tracefirst($_[1]),
2457
					 q{envelope},
2458
					 $tracelevel)
2459
					if defined $::RD_TRACE;
2460
		return undef;
2461
	}
2462
	if (!defined($return) && defined($score))
2463
	{
2464
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2465
					  q{envelope},
2466
					  $tracelevel)
2467
						if defined $::RD_TRACE;
2468
		$return = $score_return;
2469
	}
2470
	splice @{$thisparser->{errors}}, $err_at;
2471
	$return = $item[$#item] unless defined $return;
2472
	if (defined $::RD_TRACE)
2473
	{
2474
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2475
					  $return . q{])}, "",
2476
					  q{envelope},
2477
					  $tracelevel);
2478
		Parse::RecDescent::_trace(q{(consumed: [} .
2479
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
2480
					  Parse::RecDescent::_tracefirst($text),
2481
					  , q{envelope},
2482
					  $tracelevel)
2483
	}
2484
	$_[1] = $text;
2485
	return $return;
2486
}
2487
 
2488
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2489
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::MESSAGE
2490
{
2491
	my $thisparser = $_[0];
2492
	use vars q{$tracelevel};
2493
	local $tracelevel = ($tracelevel||0)+1;
2494
	$ERRORS = 0;
2495
	my $thisrule = $thisparser->{"rules"}{"MESSAGE"};
2496
 
2497
	Parse::RecDescent::_trace(q{Trying rule: [MESSAGE]},
2498
				  Parse::RecDescent::_tracefirst($_[1]),
2499
				  q{MESSAGE},
2500
				  $tracelevel)
2501
					if defined $::RD_TRACE;
2502
 
2503
	my $def_at = @{$thisparser->{deferred}};
2504
	my $err_at = @{$thisparser->{errors}};
2505
 
2506
	my $score;
2507
	my $score_return;
2508
	my $_tok;
2509
	my $return = undef;
2510
	my $_matched=0;
2511
	my $commit=0;
2512
	my @item = ();
2513
	my %item = ();
2514
	my $repeating =  defined($_[2]) && $_[2];
2515
	my $_noactions = defined($_[3]) && $_[3];
2516
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
2517
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
2518
	my $text;
2519
	my $lastsep="";
2520
    my $expectation = new Parse::RecDescent::Expectation(q{/^"MESSAGE"|^MESSAGE/i});
2521
	$expectation->at($_[1]);
2522
 
2523
	my $thisline;
2524
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2525
 
2526
 
2527
 
2528
	while (!$_matched && !$commit)
2529
	{
2530
 
2531
		Parse::RecDescent::_trace(q{Trying production: [/^"MESSAGE"|^MESSAGE/i]},
2532
					  Parse::RecDescent::_tracefirst($_[1]),
2533
					  q{MESSAGE},
2534
					  $tracelevel)
2535
						if defined $::RD_TRACE;
2536
		my $thisprod = $thisrule->{"prods"}[0];
2537
		$text = $_[1];
2538
		my $_savetext;
2539
		@item = (q{MESSAGE});
2540
		%item = (__RULE__ => q{MESSAGE});
2541
		my $repcount = 0;
2542
 
2543
 
2544
		Parse::RecDescent::_trace(q{Trying terminal: [/^"MESSAGE"|^MESSAGE/i]}, Parse::RecDescent::_tracefirst($text),
2545
					  q{MESSAGE},
2546
					  $tracelevel)
2547
						if defined $::RD_TRACE;
2548
		$lastsep = "";
2549
		$expectation->is(q{})->at($text);
2550
 
2551
 
2552
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:^"MESSAGE"|^MESSAGE)//i)
2553
		{
2554
 
2555
			$expectation->failed();
2556
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
2557
						  Parse::RecDescent::_tracefirst($text))
2558
					if defined $::RD_TRACE;
2559
 
2560
			last;
2561
		}
2562
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2563
						. $& . q{])},
2564
						  Parse::RecDescent::_tracefirst($text))
2565
					if defined $::RD_TRACE;
2566
		push @item, $item{__PATTERN1__}=$&;
2567
 
2568
 
2569
		Parse::RecDescent::_trace(q{Trying action},
2570
					  Parse::RecDescent::_tracefirst($text),
2571
					  q{MESSAGE},
2572
					  $tracelevel)
2573
						if defined $::RD_TRACE;
2574
 
2575
 
2576
		$_tok = ($_noactions) ? 0 : do { $return = "MESSAGE" 	};
2577
		unless (defined $_tok)
2578
		{
2579
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
2580
					if defined $::RD_TRACE;
2581
			last;
2582
		}
2583
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2584
					  . $_tok . q{])},
2585
					  Parse::RecDescent::_tracefirst($text))
2586
						if defined $::RD_TRACE;
2587
		push @item, $_tok;
2588
		$item{__ACTION1__}=$_tok;
2589
 
2590
 
2591
 
2592
		Parse::RecDescent::_trace(q{>>Matched production: [/^"MESSAGE"|^MESSAGE/i]<<},
2593
					  Parse::RecDescent::_tracefirst($text),
2594
					  q{MESSAGE},
2595
					  $tracelevel)
2596
						if defined $::RD_TRACE;
2597
		$_matched = 1;
2598
		last;
2599
	}
2600
 
2601
		splice
2602
				@{$thisparser->{deferred}}, $def_at unless $_matched;
2603
 
2604
        unless ( $_matched || defined($score) )
2605
	{
2606
				splice @{$thisparser->{deferred}}, $def_at;
2607
 
2608
 
2609
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
2610
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
2611
					 Parse::RecDescent::_tracefirst($_[1]),
2612
					 q{MESSAGE},
2613
					 $tracelevel)
2614
					if defined $::RD_TRACE;
2615
		return undef;
2616
	}
2617
	if (!defined($return) && defined($score))
2618
	{
2619
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2620
					  q{MESSAGE},
2621
					  $tracelevel)
2622
						if defined $::RD_TRACE;
2623
		$return = $score_return;
2624
	}
2625
	splice @{$thisparser->{errors}}, $err_at;
2626
	$return = $item[$#item] unless defined $return;
2627
	if (defined $::RD_TRACE)
2628
	{
2629
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2630
					  $return . q{])}, "",
2631
					  q{MESSAGE},
2632
					  $tracelevel);
2633
		Parse::RecDescent::_trace(q{(consumed: [} .
2634
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
2635
					  Parse::RecDescent::_tracefirst($text),
2636
					  , q{MESSAGE},
2637
					  $tracelevel)
2638
	}
2639
	$_[1] = $text;
2640
	return $return;
2641
}
2642
 
2643
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2644
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::DOUBLE_QUOTED_STRING
2645
{
2646
	my $thisparser = $_[0];
2647
	use vars q{$tracelevel};
2648
	local $tracelevel = ($tracelevel||0)+1;
2649
	$ERRORS = 0;
2650
	my $thisrule = $thisparser->{"rules"}{"DOUBLE_QUOTED_STRING"};
2651
 
2652
	Parse::RecDescent::_trace(q{Trying rule: [DOUBLE_QUOTED_STRING]},
2653
				  Parse::RecDescent::_tracefirst($_[1]),
2654
				  q{DOUBLE_QUOTED_STRING},
2655
				  $tracelevel)
2656
					if defined $::RD_TRACE;
2657
 
2658
	my $def_at = @{$thisparser->{deferred}};
2659
	my $err_at = @{$thisparser->{errors}};
2660
 
2661
	my $score;
2662
	my $score_return;
2663
	my $_tok;
2664
	my $return = undef;
2665
	my $_matched=0;
2666
	my $commit=0;
2667
	my @item = ();
2668
	my %item = ();
2669
	my $repeating =  defined($_[2]) && $_[2];
2670
	my $_noactions = defined($_[3]) && $_[3];
2671
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
2672
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
2673
	my $text;
2674
	my $lastsep="";
2675
    my $expectation = new Parse::RecDescent::Expectation(q{'"'});
2676
	$expectation->at($_[1]);
2677
 
2678
	my $thisline;
2679
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2680
 
2681
 
2682
 
2683
	while (!$_matched && !$commit)
2684
	{
2685
 
2686
		Parse::RecDescent::_trace(q{Trying production: ['"' /(?:\\\\"|[^"])*/ '"']},
2687
					  Parse::RecDescent::_tracefirst($_[1]),
2688
					  q{DOUBLE_QUOTED_STRING},
2689
					  $tracelevel)
2690
						if defined $::RD_TRACE;
2691
		my $thisprod = $thisrule->{"prods"}[0];
2692
		$text = $_[1];
2693
		my $_savetext;
2694
		@item = (q{DOUBLE_QUOTED_STRING});
2695
		%item = (__RULE__ => q{DOUBLE_QUOTED_STRING});
2696
		my $repcount = 0;
2697
 
2698
 
2699
		Parse::RecDescent::_trace(q{Trying terminal: ['"']},
2700
					  Parse::RecDescent::_tracefirst($text),
2701
					  q{DOUBLE_QUOTED_STRING},
2702
					  $tracelevel)
2703
						if defined $::RD_TRACE;
2704
		$lastsep = "";
2705
		$expectation->is(q{})->at($text);
2706
 
2707
 
2708
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A\"//)
2709
		{
2710
 
2711
			$expectation->failed();
2712
			Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
2713
						  Parse::RecDescent::_tracefirst($text))
2714
							if defined $::RD_TRACE;
2715
			last;
2716
		}
2717
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2718
						. $& . q{])},
2719
						  Parse::RecDescent::_tracefirst($text))
2720
							if defined $::RD_TRACE;
2721
		push @item, $item{__STRING1__}=$&;
2722
 
2723
 
2724
		Parse::RecDescent::_trace(q{Trying terminal: [/(?:\\\\"|[^"])*/]}, Parse::RecDescent::_tracefirst($text),
2725
					  q{DOUBLE_QUOTED_STRING},
2726
					  $tracelevel)
2727
						if defined $::RD_TRACE;
2728
		$lastsep = "";
2729
		$expectation->is(q{/(?:\\\\"|[^"])*/})->at($text);
2730
 
2731
 
2732
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:(?:\\"|[^"])*)//)
2733
		{
2734
 
2735
			$expectation->failed();
2736
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
2737
						  Parse::RecDescent::_tracefirst($text))
2738
					if defined $::RD_TRACE;
2739
 
2740
			last;
2741
		}
2742
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2743
						. $& . q{])},
2744
						  Parse::RecDescent::_tracefirst($text))
2745
					if defined $::RD_TRACE;
2746
		push @item, $item{__PATTERN1__}=$&;
2747
 
2748
 
2749
		Parse::RecDescent::_trace(q{Trying terminal: ['"']},
2750
					  Parse::RecDescent::_tracefirst($text),
2751
					  q{DOUBLE_QUOTED_STRING},
2752
					  $tracelevel)
2753
						if defined $::RD_TRACE;
2754
		$lastsep = "";
2755
		$expectation->is(q{'"'})->at($text);
2756
 
2757
 
2758
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A\"//)
2759
		{
2760
 
2761
			$expectation->failed();
2762
			Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
2763
						  Parse::RecDescent::_tracefirst($text))
2764
							if defined $::RD_TRACE;
2765
			last;
2766
		}
2767
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2768
						. $& . q{])},
2769
						  Parse::RecDescent::_tracefirst($text))
2770
							if defined $::RD_TRACE;
2771
		push @item, $item{__STRING2__}=$&;
2772
 
2773
 
2774
		Parse::RecDescent::_trace(q{Trying action},
2775
					  Parse::RecDescent::_tracefirst($text),
2776
					  q{DOUBLE_QUOTED_STRING},
2777
					  $tracelevel)
2778
						if defined $::RD_TRACE;
2779
 
2780
 
2781
		$_tok = ($_noactions) ? 0 : do {
2782
 
2783
	 $return = $item{__PATTERN1__} ;
2784
	 $return||defined($return);
2785
};
2786
		unless (defined $_tok)
2787
		{
2788
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
2789
					if defined $::RD_TRACE;
2790
			last;
2791
		}
2792
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2793
					  . $_tok . q{])},
2794
					  Parse::RecDescent::_tracefirst($text))
2795
						if defined $::RD_TRACE;
2796
		push @item, $_tok;
2797
		$item{__ACTION1__}=$_tok;
2798
 
2799
 
2800
 
2801
		Parse::RecDescent::_trace(q{>>Matched production: ['"' /(?:\\\\"|[^"])*/ '"']<<},
2802
					  Parse::RecDescent::_tracefirst($text),
2803
					  q{DOUBLE_QUOTED_STRING},
2804
					  $tracelevel)
2805
						if defined $::RD_TRACE;
2806
		$_matched = 1;
2807
		last;
2808
	}
2809
 
2810
		splice
2811
				@{$thisparser->{deferred}}, $def_at unless $_matched;
2812
 
2813
        unless ( $_matched || defined($score) )
2814
	{
2815
				splice @{$thisparser->{deferred}}, $def_at;
2816
 
2817
 
2818
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
2819
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
2820
					 Parse::RecDescent::_tracefirst($_[1]),
2821
					 q{DOUBLE_QUOTED_STRING},
2822
					 $tracelevel)
2823
					if defined $::RD_TRACE;
2824
		return undef;
2825
	}
2826
	if (!defined($return) && defined($score))
2827
	{
2828
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2829
					  q{DOUBLE_QUOTED_STRING},
2830
					  $tracelevel)
2831
						if defined $::RD_TRACE;
2832
		$return = $score_return;
2833
	}
2834
	splice @{$thisparser->{errors}}, $err_at;
2835
	$return = $item[$#item] unless defined $return;
2836
	if (defined $::RD_TRACE)
2837
	{
2838
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2839
					  $return . q{])}, "",
2840
					  q{DOUBLE_QUOTED_STRING},
2841
					  $tracelevel);
2842
		Parse::RecDescent::_trace(q{(consumed: [} .
2843
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
2844
					  Parse::RecDescent::_tracefirst($text),
2845
					  , q{DOUBLE_QUOTED_STRING},
2846
					  $tracelevel)
2847
	}
2848
	$_[1] = $text;
2849
	return $return;
2850
}
2851
 
2852
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2853
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::subject
2854
{
2855
	my $thisparser = $_[0];
2856
	use vars q{$tracelevel};
2857
	local $tracelevel = ($tracelevel||0)+1;
2858
	$ERRORS = 0;
2859
	my $thisrule = $thisparser->{"rules"}{"subject"};
2860
 
2861
	Parse::RecDescent::_trace(q{Trying rule: [subject]},
2862
				  Parse::RecDescent::_tracefirst($_[1]),
2863
				  q{subject},
2864
				  $tracelevel)
2865
					if defined $::RD_TRACE;
2866
 
2867
	my $def_at = @{$thisparser->{deferred}};
2868
	my $err_at = @{$thisparser->{errors}};
2869
 
2870
	my $score;
2871
	my $score_return;
2872
	my $_tok;
2873
	my $return = undef;
2874
	my $_matched=0;
2875
	my $commit=0;
2876
	my @item = ();
2877
	my %item = ();
2878
	my $repeating =  defined($_[2]) && $_[2];
2879
	my $_noactions = defined($_[3]) && $_[3];
2880
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
2881
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
2882
	my $text;
2883
	my $lastsep="";
2884
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or STRING});
2885
	$expectation->at($_[1]);
2886
 
2887
	my $thisline;
2888
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2889
 
2890
 
2891
 
2892
	while (!$_matched && !$commit)
2893
	{
2894
 
2895
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
2896
					  Parse::RecDescent::_tracefirst($_[1]),
2897
					  q{subject},
2898
					  $tracelevel)
2899
						if defined $::RD_TRACE;
2900
		my $thisprod = $thisrule->{"prods"}[0];
2901
		$text = $_[1];
2902
		my $_savetext;
2903
		@item = (q{subject});
2904
		%item = (__RULE__ => q{subject});
2905
		my $repcount = 0;
2906
 
2907
 
2908
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
2909
				  Parse::RecDescent::_tracefirst($text),
2910
				  q{subject},
2911
				  $tracelevel)
2912
					if defined $::RD_TRACE;
2913
		if (1) { no strict qw{refs};
2914
		$expectation->is(q{})->at($text);
2915
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2916
		{
2917
 
2918
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
2919
						  Parse::RecDescent::_tracefirst($text),
2920
						  q{subject},
2921
						  $tracelevel)
2922
							if defined $::RD_TRACE;
2923
			$expectation->failed();
2924
			last;
2925
		}
2926
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
2927
					. $_tok . q{]},
2928
 
2929
					  Parse::RecDescent::_tracefirst($text),
2930
					  q{subject},
2931
					  $tracelevel)
2932
						if defined $::RD_TRACE;
2933
		$item{q{NIL}} = $_tok;
2934
		push @item, $_tok;
2935
 
2936
		}
2937
 
2938
 
2939
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
2940
					  Parse::RecDescent::_tracefirst($text),
2941
					  q{subject},
2942
					  $tracelevel)
2943
						if defined $::RD_TRACE;
2944
		$_matched = 1;
2945
		last;
2946
	}
2947
 
2948
		splice
2949
				@{$thisparser->{deferred}}, $def_at unless $_matched;
2950
 
2951
	while (!$_matched && !$commit)
2952
	{
2953
 
2954
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
2955
					  Parse::RecDescent::_tracefirst($_[1]),
2956
					  q{subject},
2957
					  $tracelevel)
2958
						if defined $::RD_TRACE;
2959
		my $thisprod = $thisrule->{"prods"}[1];
2960
		$text = $_[1];
2961
		my $_savetext;
2962
		@item = (q{subject});
2963
		%item = (__RULE__ => q{subject});
2964
		my $repcount = 0;
2965
 
2966
 
2967
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
2968
				  Parse::RecDescent::_tracefirst($text),
2969
				  q{subject},
2970
				  $tracelevel)
2971
					if defined $::RD_TRACE;
2972
		if (1) { no strict qw{refs};
2973
		$expectation->is(q{})->at($text);
2974
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2975
		{
2976
 
2977
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
2978
						  Parse::RecDescent::_tracefirst($text),
2979
						  q{subject},
2980
						  $tracelevel)
2981
							if defined $::RD_TRACE;
2982
			$expectation->failed();
2983
			last;
2984
		}
2985
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
2986
					. $_tok . q{]},
2987
 
2988
					  Parse::RecDescent::_tracefirst($text),
2989
					  q{subject},
2990
					  $tracelevel)
2991
						if defined $::RD_TRACE;
2992
		$item{q{STRING}} = $_tok;
2993
		push @item, $_tok;
2994
 
2995
		}
2996
 
2997
		Parse::RecDescent::_trace(q{Trying action},
2998
					  Parse::RecDescent::_tracefirst($text),
2999
					  q{subject},
3000
					  $tracelevel)
3001
						if defined $::RD_TRACE;
3002
 
3003
 
3004
		$_tok = ($_noactions) ? 0 : do { 
3005
			$return = $item{NIL} || $item{STRING} ;
3006
			$return||defined($return);
3007
		};
3008
		unless (defined $_tok)
3009
		{
3010
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
3011
					if defined $::RD_TRACE;
3012
			last;
3013
		}
3014
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3015
					  . $_tok . q{])},
3016
					  Parse::RecDescent::_tracefirst($text))
3017
						if defined $::RD_TRACE;
3018
		push @item, $_tok;
3019
		$item{__ACTION1__}=$_tok;
3020
 
3021
 
3022
 
3023
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
3024
					  Parse::RecDescent::_tracefirst($text),
3025
					  q{subject},
3026
					  $tracelevel)
3027
						if defined $::RD_TRACE;
3028
		$_matched = 1;
3029
		last;
3030
	}
3031
 
3032
		splice
3033
				@{$thisparser->{deferred}}, $def_at unless $_matched;
3034
 
3035
        unless ( $_matched || defined($score) )
3036
	{
3037
				splice @{$thisparser->{deferred}}, $def_at;
3038
 
3039
 
3040
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
3041
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
3042
					 Parse::RecDescent::_tracefirst($_[1]),
3043
					 q{subject},
3044
					 $tracelevel)
3045
					if defined $::RD_TRACE;
3046
		return undef;
3047
	}
3048
	if (!defined($return) && defined($score))
3049
	{
3050
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3051
					  q{subject},
3052
					  $tracelevel)
3053
						if defined $::RD_TRACE;
3054
		$return = $score_return;
3055
	}
3056
	splice @{$thisparser->{errors}}, $err_at;
3057
	$return = $item[$#item] unless defined $return;
3058
	if (defined $::RD_TRACE)
3059
	{
3060
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3061
					  $return . q{])}, "",
3062
					  q{subject},
3063
					  $tracelevel);
3064
		Parse::RecDescent::_trace(q{(consumed: [} .
3065
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
3066
					  Parse::RecDescent::_tracefirst($text),
3067
					  , q{subject},
3068
					  $tracelevel)
3069
	}
3070
	$_[1] = $text;
3071
	return $return;
3072
}
3073
 
3074
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3075
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::value
3076
{
3077
	my $thisparser = $_[0];
3078
	use vars q{$tracelevel};
3079
	local $tracelevel = ($tracelevel||0)+1;
3080
	$ERRORS = 0;
3081
	my $thisrule = $thisparser->{"rules"}{"value"};
3082
 
3083
	Parse::RecDescent::_trace(q{Trying rule: [value]},
3084
				  Parse::RecDescent::_tracefirst($_[1]),
3085
				  q{value},
3086
				  $tracelevel)
3087
					if defined $::RD_TRACE;
3088
 
3089
	my $def_at = @{$thisparser->{deferred}};
3090
	my $err_at = @{$thisparser->{errors}};
3091
 
3092
	my $score;
3093
	my $score_return;
3094
	my $_tok;
3095
	my $return = undef;
3096
	my $_matched=0;
3097
	my $commit=0;
3098
	my @item = ();
3099
	my %item = ();
3100
	my $repeating =  defined($_[2]) && $_[2];
3101
	my $_noactions = defined($_[3]) && $_[3];
3102
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
3103
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
3104
	my $text;
3105
	my $lastsep="";
3106
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or '(', or NUMBER, or STRING});
3107
	$expectation->at($_[1]);
3108
 
3109
	my $thisline;
3110
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3111
 
3112
 
3113
 
3114
	while (!$_matched && !$commit)
3115
	{
3116
 
3117
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
3118
					  Parse::RecDescent::_tracefirst($_[1]),
3119
					  q{value},
3120
					  $tracelevel)
3121
						if defined $::RD_TRACE;
3122
		my $thisprod = $thisrule->{"prods"}[0];
3123
		$text = $_[1];
3124
		my $_savetext;
3125
		@item = (q{value});
3126
		%item = (__RULE__ => q{value});
3127
		my $repcount = 0;
3128
 
3129
 
3130
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
3131
				  Parse::RecDescent::_tracefirst($text),
3132
				  q{value},
3133
				  $tracelevel)
3134
					if defined $::RD_TRACE;
3135
		if (1) { no strict qw{refs};
3136
		$expectation->is(q{})->at($text);
3137
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
3138
		{
3139
 
3140
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
3141
						  Parse::RecDescent::_tracefirst($text),
3142
						  q{value},
3143
						  $tracelevel)
3144
							if defined $::RD_TRACE;
3145
			$expectation->failed();
3146
			last;
3147
		}
3148
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
3149
					. $_tok . q{]},
3150
 
3151
					  Parse::RecDescent::_tracefirst($text),
3152
					  q{value},
3153
					  $tracelevel)
3154
						if defined $::RD_TRACE;
3155
		$item{q{NIL}} = $_tok;
3156
		push @item, $_tok;
3157
 
3158
		}
3159
 
3160
 
3161
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
3162
					  Parse::RecDescent::_tracefirst($text),
3163
					  q{value},
3164
					  $tracelevel)
3165
						if defined $::RD_TRACE;
3166
		$_matched = 1;
3167
		last;
3168
	}
3169
 
3170
		splice
3171
				@{$thisparser->{deferred}}, $def_at unless $_matched;
3172
 
3173
	while (!$_matched && !$commit)
3174
	{
3175
 
3176
		Parse::RecDescent::_trace(q{Trying production: ['(' <commit> kvpair ')']},
3177
					  Parse::RecDescent::_tracefirst($_[1]),
3178
					  q{value},
3179
					  $tracelevel)
3180
						if defined $::RD_TRACE;
3181
		my $thisprod = $thisrule->{"prods"}[1];
3182
		$text = $_[1];
3183
		my $_savetext;
3184
		@item = (q{value});
3185
		%item = (__RULE__ => q{value});
3186
		my $repcount = 0;
3187
 
3188
 
3189
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
3190
					  Parse::RecDescent::_tracefirst($text),
3191
					  q{value},
3192
					  $tracelevel)
3193
						if defined $::RD_TRACE;
3194
		$lastsep = "";
3195
		$expectation->is(q{})->at($text);
3196
 
3197
 
3198
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A\(//)
3199
		{
3200
 
3201
			$expectation->failed();
3202
			Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
3203
						  Parse::RecDescent::_tracefirst($text))
3204
							if defined $::RD_TRACE;
3205
			last;
3206
		}
3207
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3208
						. $& . q{])},
3209
						  Parse::RecDescent::_tracefirst($text))
3210
							if defined $::RD_TRACE;
3211
		push @item, $item{__STRING1__}=$&;
3212
 
3213
 
3214
 
3215
 
3216
		Parse::RecDescent::_trace(q{Trying directive: [<commit>]},
3217
					Parse::RecDescent::_tracefirst($text),
3218
					  q{value},
3219
					  $tracelevel)
3220
						if defined $::RD_TRACE; 
3221
		$_tok = do { $commit = 1 };
3222
		if (defined($_tok))
3223
		{
3224
			Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
3225
						. $_tok . q{])},
3226
						Parse::RecDescent::_tracefirst($text))
3227
							if defined $::RD_TRACE;
3228
		}
3229
		else
3230
		{
3231
			Parse::RecDescent::_trace(q{<<Didn't match directive>>},
3232
						Parse::RecDescent::_tracefirst($text))
3233
							if defined $::RD_TRACE;
3234
		}
3235
 
3236
		last unless defined $_tok;
3237
		push @item, $item{__DIRECTIVE1__}=$_tok;
3238
 
3239
 
3240
		Parse::RecDescent::_trace(q{Trying repeated subrule: [kvpair]},
3241
				  Parse::RecDescent::_tracefirst($text),
3242
				  q{value},
3243
				  $tracelevel)
3244
					if defined $::RD_TRACE;
3245
		$expectation->is(q{kvpair})->at($text);
3246
 
3247
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::kvpair, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
3248
		{
3249
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [kvpair]>>},
3250
						  Parse::RecDescent::_tracefirst($text),
3251
						  q{value},
3252
						  $tracelevel)
3253
							if defined $::RD_TRACE;
3254
			last;
3255
		}
3256
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [kvpair]<< (}
3257
					. @$_tok . q{ times)},
3258
 
3259
					  Parse::RecDescent::_tracefirst($text),
3260
					  q{value},
3261
					  $tracelevel)
3262
						if defined $::RD_TRACE;
3263
		$item{q{kvpair(s)}} = $_tok;
3264
		push @item, $_tok;
3265
 
3266
 
3267
 
3268
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
3269
					  Parse::RecDescent::_tracefirst($text),
3270
					  q{value},
3271
					  $tracelevel)
3272
						if defined $::RD_TRACE;
3273
		$lastsep = "";
3274
		$expectation->is(q{')'})->at($text);
3275
 
3276
 
3277
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A\)//)
3278
		{
3279
 
3280
			$expectation->failed();
3281
			Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
3282
						  Parse::RecDescent::_tracefirst($text))
3283
							if defined $::RD_TRACE;
3284
			last;
3285
		}
3286
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3287
						. $& . q{])},
3288
						  Parse::RecDescent::_tracefirst($text))
3289
							if defined $::RD_TRACE;
3290
		push @item, $item{__STRING2__}=$&;
3291
 
3292
 
3293
 
3294
		Parse::RecDescent::_trace(q{>>Matched production: ['(' <commit> kvpair ')']<<},
3295
					  Parse::RecDescent::_tracefirst($text),
3296
					  q{value},
3297
					  $tracelevel)
3298
						if defined $::RD_TRACE;
3299
		$_matched = 1;
3300
		last;
3301
	}
3302
 
3303
		splice
3304
				@{$thisparser->{deferred}}, $def_at unless $_matched;
3305
 
3306
	while (!$_matched && !$commit)
3307
	{
3308
 
3309
		Parse::RecDescent::_trace(q{Trying production: [NUMBER]},
3310
					  Parse::RecDescent::_tracefirst($_[1]),
3311
					  q{value},
3312
					  $tracelevel)
3313
						if defined $::RD_TRACE;
3314
		my $thisprod = $thisrule->{"prods"}[2];
3315
		$text = $_[1];
3316
		my $_savetext;
3317
		@item = (q{value});
3318
		%item = (__RULE__ => q{value});
3319
		my $repcount = 0;
3320
 
3321
 
3322
		Parse::RecDescent::_trace(q{Trying subrule: [NUMBER]},
3323
				  Parse::RecDescent::_tracefirst($text),
3324
				  q{value},
3325
				  $tracelevel)
3326
					if defined $::RD_TRACE;
3327
		if (1) { no strict qw{refs};
3328
		$expectation->is(q{})->at($text);
3329
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NUMBER($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
3330
		{
3331
 
3332
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NUMBER]>>},
3333
						  Parse::RecDescent::_tracefirst($text),
3334
						  q{value},
3335
						  $tracelevel)
3336
							if defined $::RD_TRACE;
3337
			$expectation->failed();
3338
			last;
3339
		}
3340
		Parse::RecDescent::_trace(q{>>Matched subrule: [NUMBER]<< (return value: [}
3341
					. $_tok . q{]},
3342
 
3343
					  Parse::RecDescent::_tracefirst($text),
3344
					  q{value},
3345
					  $tracelevel)
3346
						if defined $::RD_TRACE;
3347
		$item{q{NUMBER}} = $_tok;
3348
		push @item, $_tok;
3349
 
3350
		}
3351
 
3352
 
3353
		Parse::RecDescent::_trace(q{>>Matched production: [NUMBER]<<},
3354
					  Parse::RecDescent::_tracefirst($text),
3355
					  q{value},
3356
					  $tracelevel)
3357
						if defined $::RD_TRACE;
3358
		$_matched = 1;
3359
		last;
3360
	}
3361
 
3362
		splice
3363
				@{$thisparser->{deferred}}, $def_at unless $_matched;
3364
 
3365
	while (!$_matched && !$commit)
3366
	{
3367
 
3368
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
3369
					  Parse::RecDescent::_tracefirst($_[1]),
3370
					  q{value},
3371
					  $tracelevel)
3372
						if defined $::RD_TRACE;
3373
		my $thisprod = $thisrule->{"prods"}[3];
3374
		$text = $_[1];
3375
		my $_savetext;
3376
		@item = (q{value});
3377
		%item = (__RULE__ => q{value});
3378
		my $repcount = 0;
3379
 
3380
 
3381
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
3382
				  Parse::RecDescent::_tracefirst($text),
3383
				  q{value},
3384
				  $tracelevel)
3385
					if defined $::RD_TRACE;
3386
		if (1) { no strict qw{refs};
3387
		$expectation->is(q{})->at($text);
3388
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
3389
		{
3390
 
3391
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
3392
						  Parse::RecDescent::_tracefirst($text),
3393
						  q{value},
3394
						  $tracelevel)
3395
							if defined $::RD_TRACE;
3396
			$expectation->failed();
3397
			last;
3398
		}
3399
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
3400
					. $_tok . q{]},
3401
 
3402
					  Parse::RecDescent::_tracefirst($text),
3403
					  q{value},
3404
					  $tracelevel)
3405
						if defined $::RD_TRACE;
3406
		$item{q{STRING}} = $_tok;
3407
		push @item, $_tok;
3408
 
3409
		}
3410
 
3411
		Parse::RecDescent::_trace(q{Trying action},
3412
					  Parse::RecDescent::_tracefirst($text),
3413
					  q{value},
3414
					  $tracelevel)
3415
						if defined $::RD_TRACE;
3416
 
3417
 
3418
		$_tok = ($_noactions) ? 0 : do { 	$return = $item{NIL} 		|| 
3419
			$item{NUMBER} 			|| 
3420
			$item{STRING} 			|| 
3421
			{ map { (%$_) } @{$item{'kvpair(s)'}} } ;
3422
			$return||defined($return);
3423
		};
3424
		unless (defined $_tok)
3425
		{
3426
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
3427
					if defined $::RD_TRACE;
3428
			last;
3429
		}
3430
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3431
					  . $_tok . q{])},
3432
					  Parse::RecDescent::_tracefirst($text))
3433
						if defined $::RD_TRACE;
3434
		push @item, $_tok;
3435
		$item{__ACTION1__}=$_tok;
3436
 
3437
 
3438
 
3439
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
3440
					  Parse::RecDescent::_tracefirst($text),
3441
					  q{value},
3442
					  $tracelevel)
3443
						if defined $::RD_TRACE;
3444
		$_matched = 1;
3445
		last;
3446
	}
3447
 
3448
		splice
3449
				@{$thisparser->{deferred}}, $def_at unless $_matched;
3450
 
3451
        unless ( $_matched || defined($score) )
3452
	{
3453
				splice @{$thisparser->{deferred}}, $def_at;
3454
 
3455
 
3456
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
3457
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
3458
					 Parse::RecDescent::_tracefirst($_[1]),
3459
					 q{value},
3460
					 $tracelevel)
3461
					if defined $::RD_TRACE;
3462
		return undef;
3463
	}
3464
	if (!defined($return) && defined($score))
3465
	{
3466
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3467
					  q{value},
3468
					  $tracelevel)
3469
						if defined $::RD_TRACE;
3470
		$return = $score_return;
3471
	}
3472
	splice @{$thisparser->{errors}}, $err_at;
3473
	$return = $item[$#item] unless defined $return;
3474
	if (defined $::RD_TRACE)
3475
	{
3476
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3477
					  $return . q{])}, "",
3478
					  q{value},
3479
					  $tracelevel);
3480
		Parse::RecDescent::_trace(q{(consumed: [} .
3481
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
3482
					  Parse::RecDescent::_tracefirst($text),
3483
					  , q{value},
3484
					  $tracelevel)
3485
	}
3486
	$_[1] = $text;
3487
	return $return;
3488
}
3489
 
3490
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3491
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::inreplyto
3492
{
3493
	my $thisparser = $_[0];
3494
	use vars q{$tracelevel};
3495
	local $tracelevel = ($tracelevel||0)+1;
3496
	$ERRORS = 0;
3497
	my $thisrule = $thisparser->{"rules"}{"inreplyto"};
3498
 
3499
	Parse::RecDescent::_trace(q{Trying rule: [inreplyto]},
3500
				  Parse::RecDescent::_tracefirst($_[1]),
3501
				  q{inreplyto},
3502
				  $tracelevel)
3503
					if defined $::RD_TRACE;
3504
 
3505
	my $def_at = @{$thisparser->{deferred}};
3506
	my $err_at = @{$thisparser->{errors}};
3507
 
3508
	my $score;
3509
	my $score_return;
3510
	my $_tok;
3511
	my $return = undef;
3512
	my $_matched=0;
3513
	my $commit=0;
3514
	my @item = ();
3515
	my %item = ();
3516
	my $repeating =  defined($_[2]) && $_[2];
3517
	my $_noactions = defined($_[3]) && $_[3];
3518
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
3519
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
3520
	my $text;
3521
	my $lastsep="";
3522
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or STRING});
3523
	$expectation->at($_[1]);
3524
 
3525
	my $thisline;
3526
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3527
 
3528
 
3529
 
3530
	while (!$_matched && !$commit)
3531
	{
3532
 
3533
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
3534
					  Parse::RecDescent::_tracefirst($_[1]),
3535
					  q{inreplyto},
3536
					  $tracelevel)
3537
						if defined $::RD_TRACE;
3538
		my $thisprod = $thisrule->{"prods"}[0];
3539
		$text = $_[1];
3540
		my $_savetext;
3541
		@item = (q{inreplyto});
3542
		%item = (__RULE__ => q{inreplyto});
3543
		my $repcount = 0;
3544
 
3545
 
3546
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
3547
				  Parse::RecDescent::_tracefirst($text),
3548
				  q{inreplyto},
3549
				  $tracelevel)
3550
					if defined $::RD_TRACE;
3551
		if (1) { no strict qw{refs};
3552
		$expectation->is(q{})->at($text);
3553
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
3554
		{
3555
 
3556
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
3557
						  Parse::RecDescent::_tracefirst($text),
3558
						  q{inreplyto},
3559
						  $tracelevel)
3560
							if defined $::RD_TRACE;
3561
			$expectation->failed();
3562
			last;
3563
		}
3564
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
3565
					. $_tok . q{]},
3566
 
3567
					  Parse::RecDescent::_tracefirst($text),
3568
					  q{inreplyto},
3569
					  $tracelevel)
3570
						if defined $::RD_TRACE;
3571
		$item{q{NIL}} = $_tok;
3572
		push @item, $_tok;
3573
 
3574
		}
3575
 
3576
 
3577
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
3578
					  Parse::RecDescent::_tracefirst($text),
3579
					  q{inreplyto},
3580
					  $tracelevel)
3581
						if defined $::RD_TRACE;
3582
		$_matched = 1;
3583
		last;
3584
	}
3585
 
3586
		splice
3587
				@{$thisparser->{deferred}}, $def_at unless $_matched;
3588
 
3589
	while (!$_matched && !$commit)
3590
	{
3591
 
3592
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
3593
					  Parse::RecDescent::_tracefirst($_[1]),
3594
					  q{inreplyto},
3595
					  $tracelevel)
3596
						if defined $::RD_TRACE;
3597
		my $thisprod = $thisrule->{"prods"}[1];
3598
		$text = $_[1];
3599
		my $_savetext;
3600
		@item = (q{inreplyto});
3601
		%item = (__RULE__ => q{inreplyto});
3602
		my $repcount = 0;
3603
 
3604
 
3605
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
3606
				  Parse::RecDescent::_tracefirst($text),
3607
				  q{inreplyto},
3608
				  $tracelevel)
3609
					if defined $::RD_TRACE;
3610
		if (1) { no strict qw{refs};
3611
		$expectation->is(q{})->at($text);
3612
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
3613
		{
3614
 
3615
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
3616
						  Parse::RecDescent::_tracefirst($text),
3617
						  q{inreplyto},
3618
						  $tracelevel)
3619
							if defined $::RD_TRACE;
3620
			$expectation->failed();
3621
			last;
3622
		}
3623
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
3624
					. $_tok . q{]},
3625
 
3626
					  Parse::RecDescent::_tracefirst($text),
3627
					  q{inreplyto},
3628
					  $tracelevel)
3629
						if defined $::RD_TRACE;
3630
		$item{q{STRING}} = $_tok;
3631
		push @item, $_tok;
3632
 
3633
		}
3634
 
3635
		Parse::RecDescent::_trace(q{Trying action},
3636
					  Parse::RecDescent::_tracefirst($text),
3637
					  q{inreplyto},
3638
					  $tracelevel)
3639
						if defined $::RD_TRACE;
3640
 
3641
 
3642
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{STRING} ;$return||defined($return);};
3643
		unless (defined $_tok)
3644
		{
3645
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
3646
					if defined $::RD_TRACE;
3647
			last;
3648
		}
3649
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3650
					  . $_tok . q{])},
3651
					  Parse::RecDescent::_tracefirst($text))
3652
						if defined $::RD_TRACE;
3653
		push @item, $_tok;
3654
		$item{__ACTION1__}=$_tok;
3655
 
3656
 
3657
 
3658
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
3659
					  Parse::RecDescent::_tracefirst($text),
3660
					  q{inreplyto},
3661
					  $tracelevel)
3662
						if defined $::RD_TRACE;
3663
		$_matched = 1;
3664
		last;
3665
	}
3666
 
3667
		splice
3668
				@{$thisparser->{deferred}}, $def_at unless $_matched;
3669
 
3670
        unless ( $_matched || defined($score) )
3671
	{
3672
				splice @{$thisparser->{deferred}}, $def_at;
3673
 
3674
 
3675
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
3676
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
3677
					 Parse::RecDescent::_tracefirst($_[1]),
3678
					 q{inreplyto},
3679
					 $tracelevel)
3680
					if defined $::RD_TRACE;
3681
		return undef;
3682
	}
3683
	if (!defined($return) && defined($score))
3684
	{
3685
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3686
					  q{inreplyto},
3687
					  $tracelevel)
3688
						if defined $::RD_TRACE;
3689
		$return = $score_return;
3690
	}
3691
	splice @{$thisparser->{errors}}, $err_at;
3692
	$return = $item[$#item] unless defined $return;
3693
	if (defined $::RD_TRACE)
3694
	{
3695
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3696
					  $return . q{])}, "",
3697
					  q{inreplyto},
3698
					  $tracelevel);
3699
		Parse::RecDescent::_trace(q{(consumed: [} .
3700
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
3701
					  Parse::RecDescent::_tracefirst($text),
3702
					  , q{inreplyto},
3703
					  $tracelevel)
3704
	}
3705
	$_[1] = $text;
3706
	return $return;
3707
}
3708
 
3709
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3710
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::messageid
3711
{
3712
	my $thisparser = $_[0];
3713
	use vars q{$tracelevel};
3714
	local $tracelevel = ($tracelevel||0)+1;
3715
	$ERRORS = 0;
3716
	my $thisrule = $thisparser->{"rules"}{"messageid"};
3717
 
3718
	Parse::RecDescent::_trace(q{Trying rule: [messageid]},
3719
				  Parse::RecDescent::_tracefirst($_[1]),
3720
				  q{messageid},
3721
				  $tracelevel)
3722
					if defined $::RD_TRACE;
3723
 
3724
	my $def_at = @{$thisparser->{deferred}};
3725
	my $err_at = @{$thisparser->{errors}};
3726
 
3727
	my $score;
3728
	my $score_return;
3729
	my $_tok;
3730
	my $return = undef;
3731
	my $_matched=0;
3732
	my $commit=0;
3733
	my @item = ();
3734
	my %item = ();
3735
	my $repeating =  defined($_[2]) && $_[2];
3736
	my $_noactions = defined($_[3]) && $_[3];
3737
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
3738
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
3739
	my $text;
3740
	my $lastsep="";
3741
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or STRING});
3742
	$expectation->at($_[1]);
3743
 
3744
	my $thisline;
3745
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3746
 
3747
 
3748
 
3749
	while (!$_matched && !$commit)
3750
	{
3751
 
3752
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
3753
					  Parse::RecDescent::_tracefirst($_[1]),
3754
					  q{messageid},
3755
					  $tracelevel)
3756
						if defined $::RD_TRACE;
3757
		my $thisprod = $thisrule->{"prods"}[0];
3758
		$text = $_[1];
3759
		my $_savetext;
3760
		@item = (q{messageid});
3761
		%item = (__RULE__ => q{messageid});
3762
		my $repcount = 0;
3763
 
3764
 
3765
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
3766
				  Parse::RecDescent::_tracefirst($text),
3767
				  q{messageid},
3768
				  $tracelevel)
3769
					if defined $::RD_TRACE;
3770
		if (1) { no strict qw{refs};
3771
		$expectation->is(q{})->at($text);
3772
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
3773
		{
3774
 
3775
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
3776
						  Parse::RecDescent::_tracefirst($text),
3777
						  q{messageid},
3778
						  $tracelevel)
3779
							if defined $::RD_TRACE;
3780
			$expectation->failed();
3781
			last;
3782
		}
3783
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
3784
					. $_tok . q{]},
3785
 
3786
					  Parse::RecDescent::_tracefirst($text),
3787
					  q{messageid},
3788
					  $tracelevel)
3789
						if defined $::RD_TRACE;
3790
		$item{q{NIL}} = $_tok;
3791
		push @item, $_tok;
3792
 
3793
		}
3794
 
3795
 
3796
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
3797
					  Parse::RecDescent::_tracefirst($text),
3798
					  q{messageid},
3799
					  $tracelevel)
3800
						if defined $::RD_TRACE;
3801
		$_matched = 1;
3802
		last;
3803
	}
3804
 
3805
		splice
3806
				@{$thisparser->{deferred}}, $def_at unless $_matched;
3807
 
3808
	while (!$_matched && !$commit)
3809
	{
3810
 
3811
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
3812
					  Parse::RecDescent::_tracefirst($_[1]),
3813
					  q{messageid},
3814
					  $tracelevel)
3815
						if defined $::RD_TRACE;
3816
		my $thisprod = $thisrule->{"prods"}[1];
3817
		$text = $_[1];
3818
		my $_savetext;
3819
		@item = (q{messageid});
3820
		%item = (__RULE__ => q{messageid});
3821
		my $repcount = 0;
3822
 
3823
 
3824
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
3825
				  Parse::RecDescent::_tracefirst($text),
3826
				  q{messageid},
3827
				  $tracelevel)
3828
					if defined $::RD_TRACE;
3829
		if (1) { no strict qw{refs};
3830
		$expectation->is(q{})->at($text);
3831
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
3832
		{
3833
 
3834
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
3835
						  Parse::RecDescent::_tracefirst($text),
3836
						  q{messageid},
3837
						  $tracelevel)
3838
							if defined $::RD_TRACE;
3839
			$expectation->failed();
3840
			last;
3841
		}
3842
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
3843
					. $_tok . q{]},
3844
 
3845
					  Parse::RecDescent::_tracefirst($text),
3846
					  q{messageid},
3847
					  $tracelevel)
3848
						if defined $::RD_TRACE;
3849
		$item{q{STRING}} = $_tok;
3850
		push @item, $_tok;
3851
 
3852
		}
3853
 
3854
		Parse::RecDescent::_trace(q{Trying action},
3855
					  Parse::RecDescent::_tracefirst($text),
3856
					  q{messageid},
3857
					  $tracelevel)
3858
						if defined $::RD_TRACE;
3859
 
3860
 
3861
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{STRING} ;$return||defined($return);};
3862
		unless (defined $_tok)
3863
		{
3864
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
3865
					if defined $::RD_TRACE;
3866
			last;
3867
		}
3868
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3869
					  . $_tok . q{])},
3870
					  Parse::RecDescent::_tracefirst($text))
3871
						if defined $::RD_TRACE;
3872
		push @item, $_tok;
3873
		$item{__ACTION1__}=$_tok;
3874
 
3875
 
3876
 
3877
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
3878
					  Parse::RecDescent::_tracefirst($text),
3879
					  q{messageid},
3880
					  $tracelevel)
3881
						if defined $::RD_TRACE;
3882
		$_matched = 1;
3883
		last;
3884
	}
3885
 
3886
		splice
3887
				@{$thisparser->{deferred}}, $def_at unless $_matched;
3888
 
3889
        unless ( $_matched || defined($score) )
3890
	{
3891
				splice @{$thisparser->{deferred}}, $def_at;
3892
 
3893
 
3894
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
3895
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
3896
					 Parse::RecDescent::_tracefirst($_[1]),
3897
					 q{messageid},
3898
					 $tracelevel)
3899
					if defined $::RD_TRACE;
3900
		return undef;
3901
	}
3902
	if (!defined($return) && defined($score))
3903
	{
3904
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3905
					  q{messageid},
3906
					  $tracelevel)
3907
						if defined $::RD_TRACE;
3908
		$return = $score_return;
3909
	}
3910
	splice @{$thisparser->{errors}}, $err_at;
3911
	$return = $item[$#item] unless defined $return;
3912
	if (defined $::RD_TRACE)
3913
	{
3914
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3915
					  $return . q{])}, "",
3916
					  q{messageid},
3917
					  $tracelevel);
3918
		Parse::RecDescent::_trace(q{(consumed: [} .
3919
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
3920
					  Parse::RecDescent::_tracefirst($text),
3921
					  , q{messageid},
3922
					  $tracelevel)
3923
	}
3924
	$_[1] = $text;
3925
	return $return;
3926
}
3927
 
3928
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3929
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::sender
3930
{
3931
	my $thisparser = $_[0];
3932
	use vars q{$tracelevel};
3933
	local $tracelevel = ($tracelevel||0)+1;
3934
	$ERRORS = 0;
3935
	my $thisrule = $thisparser->{"rules"}{"sender"};
3936
 
3937
	Parse::RecDescent::_trace(q{Trying rule: [sender]},
3938
				  Parse::RecDescent::_tracefirst($_[1]),
3939
				  q{sender},
3940
				  $tracelevel)
3941
					if defined $::RD_TRACE;
3942
 
3943
	my $def_at = @{$thisparser->{deferred}};
3944
	my $err_at = @{$thisparser->{errors}};
3945
 
3946
	my $score;
3947
	my $score_return;
3948
	my $_tok;
3949
	my $return = undef;
3950
	my $_matched=0;
3951
	my $commit=0;
3952
	my @item = ();
3953
	my %item = ();
3954
	my $repeating =  defined($_[2]) && $_[2];
3955
	my $_noactions = defined($_[3]) && $_[3];
3956
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
3957
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
3958
	my $text;
3959
	my $lastsep="";
3960
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or '('});
3961
	$expectation->at($_[1]);
3962
 
3963
	my $thisline;
3964
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3965
 
3966
 
3967
 
3968
	while (!$_matched && !$commit)
3969
	{
3970
 
3971
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
3972
					  Parse::RecDescent::_tracefirst($_[1]),
3973
					  q{sender},
3974
					  $tracelevel)
3975
						if defined $::RD_TRACE;
3976
		my $thisprod = $thisrule->{"prods"}[0];
3977
		$text = $_[1];
3978
		my $_savetext;
3979
		@item = (q{sender});
3980
		%item = (__RULE__ => q{sender});
3981
		my $repcount = 0;
3982
 
3983
 
3984
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
3985
				  Parse::RecDescent::_tracefirst($text),
3986
				  q{sender},
3987
				  $tracelevel)
3988
					if defined $::RD_TRACE;
3989
		if (1) { no strict qw{refs};
3990
		$expectation->is(q{})->at($text);
3991
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
3992
		{
3993
 
3994
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
3995
						  Parse::RecDescent::_tracefirst($text),
3996
						  q{sender},
3997
						  $tracelevel)
3998
							if defined $::RD_TRACE;
3999
			$expectation->failed();
4000
			last;
4001
		}
4002
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
4003
					. $_tok . q{]},
4004
 
4005
					  Parse::RecDescent::_tracefirst($text),
4006
					  q{sender},
4007
					  $tracelevel)
4008
						if defined $::RD_TRACE;
4009
		$item{q{NIL}} = $_tok;
4010
		push @item, $_tok;
4011
 
4012
		}
4013
 
4014
 
4015
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
4016
					  Parse::RecDescent::_tracefirst($text),
4017
					  q{sender},
4018
					  $tracelevel)
4019
						if defined $::RD_TRACE;
4020
		$_matched = 1;
4021
		last;
4022
	}
4023
 
4024
		splice
4025
				@{$thisparser->{deferred}}, $def_at unless $_matched;
4026
 
4027
	while (!$_matched && !$commit)
4028
	{
4029
 
4030
		Parse::RecDescent::_trace(q{Trying production: ['(' addressstruct ')']},
4031
					  Parse::RecDescent::_tracefirst($_[1]),
4032
					  q{sender},
4033
					  $tracelevel)
4034
						if defined $::RD_TRACE;
4035
		my $thisprod = $thisrule->{"prods"}[1];
4036
		$text = $_[1];
4037
		my $_savetext;
4038
		@item = (q{sender});
4039
		%item = (__RULE__ => q{sender});
4040
		my $repcount = 0;
4041
 
4042
 
4043
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
4044
					  Parse::RecDescent::_tracefirst($text),
4045
					  q{sender},
4046
					  $tracelevel)
4047
						if defined $::RD_TRACE;
4048
		$lastsep = "";
4049
		$expectation->is(q{})->at($text);
4050
 
4051
 
4052
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "("; 1 } and
4053
		     substr($text,0,length($_tok)) eq $_tok and
4054
		     do { substr($text,0,length($_tok)) = ""; 1; }
4055
		)
4056
		{
4057
 
4058
			$expectation->failed();
4059
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
4060
						  Parse::RecDescent::_tracefirst($text))
4061
							if defined $::RD_TRACE;
4062
			last;
4063
		}
4064
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4065
						. $_tok . q{])},
4066
						  Parse::RecDescent::_tracefirst($text))
4067
							if defined $::RD_TRACE;
4068
		push @item, $item{__STRING1__}=$_tok;
4069
 
4070
 
4071
		Parse::RecDescent::_trace(q{Trying repeated subrule: [addressstruct]},
4072
				  Parse::RecDescent::_tracefirst($text),
4073
				  q{sender},
4074
				  $tracelevel)
4075
					if defined $::RD_TRACE;
4076
		$expectation->is(q{addressstruct})->at($text);
4077
 
4078
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::addressstruct, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
4079
		{
4080
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [addressstruct]>>},
4081
						  Parse::RecDescent::_tracefirst($text),
4082
						  q{sender},
4083
						  $tracelevel)
4084
							if defined $::RD_TRACE;
4085
			last;
4086
		}
4087
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [addressstruct]<< (}
4088
					. @$_tok . q{ times)},
4089
 
4090
					  Parse::RecDescent::_tracefirst($text),
4091
					  q{sender},
4092
					  $tracelevel)
4093
						if defined $::RD_TRACE;
4094
		$item{q{addressstruct(s)}} = $_tok;
4095
		push @item, $_tok;
4096
 
4097
 
4098
 
4099
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
4100
					  Parse::RecDescent::_tracefirst($text),
4101
					  q{sender},
4102
					  $tracelevel)
4103
						if defined $::RD_TRACE;
4104
		$lastsep = "";
4105
		$expectation->is(q{')'})->at($text);
4106
 
4107
 
4108
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
4109
		     substr($text,0,length($_tok)) eq $_tok and
4110
		     do { substr($text,0,length($_tok)) = ""; 1; }
4111
		)
4112
		{
4113
 
4114
			$expectation->failed();
4115
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
4116
						  Parse::RecDescent::_tracefirst($text))
4117
							if defined $::RD_TRACE;
4118
			last;
4119
		}
4120
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4121
						. $_tok . q{])},
4122
						  Parse::RecDescent::_tracefirst($text))
4123
							if defined $::RD_TRACE;
4124
		push @item, $item{__STRING2__}=$_tok;
4125
 
4126
 
4127
		Parse::RecDescent::_trace(q{Trying action},
4128
					  Parse::RecDescent::_tracefirst($text),
4129
					  q{sender},
4130
					  $tracelevel)
4131
						if defined $::RD_TRACE;
4132
 
4133
 
4134
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{'addressstruct(s)'} };
4135
		unless (defined $_tok)
4136
		{
4137
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
4138
					if defined $::RD_TRACE;
4139
			last;
4140
		}
4141
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4142
					  . $_tok . q{])},
4143
					  Parse::RecDescent::_tracefirst($text))
4144
						if defined $::RD_TRACE;
4145
		push @item, $_tok;
4146
		$item{__ACTION1__}=$_tok;
4147
 
4148
 
4149
 
4150
		Parse::RecDescent::_trace(q{>>Matched production: ['(' addressstruct ')']<<},
4151
					  Parse::RecDescent::_tracefirst($text),
4152
					  q{sender},
4153
					  $tracelevel)
4154
						if defined $::RD_TRACE;
4155
		$_matched = 1;
4156
		last;
4157
	}
4158
 
4159
		splice
4160
				@{$thisparser->{deferred}}, $def_at unless $_matched;
4161
 
4162
        unless ( $_matched || defined($score) )
4163
	{
4164
				splice @{$thisparser->{deferred}}, $def_at;
4165
 
4166
 
4167
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
4168
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
4169
					 Parse::RecDescent::_tracefirst($_[1]),
4170
					 q{sender},
4171
					 $tracelevel)
4172
					if defined $::RD_TRACE;
4173
		return undef;
4174
	}
4175
	if (!defined($return) && defined($score))
4176
	{
4177
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4178
					  q{sender},
4179
					  $tracelevel)
4180
						if defined $::RD_TRACE;
4181
		$return = $score_return;
4182
	}
4183
	splice @{$thisparser->{errors}}, $err_at;
4184
	$return = $item[$#item] unless defined $return;
4185
	if (defined $::RD_TRACE)
4186
	{
4187
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4188
					  $return . q{])}, "",
4189
					  q{sender},
4190
					  $tracelevel);
4191
		Parse::RecDescent::_trace(q{(consumed: [} .
4192
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
4193
					  Parse::RecDescent::_tracefirst($text),
4194
					  , q{sender},
4195
					  $tracelevel)
4196
	}
4197
	$_[1] = $text;
4198
	return $return;
4199
}
4200
 
4201
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
4202
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::QUOTED_STRING
4203
{
4204
	my $thisparser = $_[0];
4205
	use vars q{$tracelevel};
4206
	local $tracelevel = ($tracelevel||0)+1;
4207
	$ERRORS = 0;
4208
	my $thisrule = $thisparser->{"rules"}{"QUOTED_STRING"};
4209
 
4210
	Parse::RecDescent::_trace(q{Trying rule: [QUOTED_STRING]},
4211
				  Parse::RecDescent::_tracefirst($_[1]),
4212
				  q{QUOTED_STRING},
4213
				  $tracelevel)
4214
					if defined $::RD_TRACE;
4215
 
4216
	my $def_at = @{$thisparser->{deferred}};
4217
	my $err_at = @{$thisparser->{errors}};
4218
 
4219
	my $score;
4220
	my $score_return;
4221
	my $_tok;
4222
	my $return = undef;
4223
	my $_matched=0;
4224
	my $commit=0;
4225
	my @item = ();
4226
	my %item = ();
4227
	my $repeating =  defined($_[2]) && $_[2];
4228
	my $_noactions = defined($_[3]) && $_[3];
4229
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
4230
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
4231
	my $text;
4232
	my $lastsep="";
4233
    my $expectation = new Parse::RecDescent::Expectation(q{DOUBLE_QUOTED_STRING, or SINGLE_QUOTED_STRING});
4234
	$expectation->at($_[1]);
4235
 
4236
	my $thisline;
4237
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4238
 
4239
 
4240
 
4241
	while (!$_matched && !$commit)
4242
	{
4243
 
4244
		Parse::RecDescent::_trace(q{Trying production: [DOUBLE_QUOTED_STRING]},
4245
					  Parse::RecDescent::_tracefirst($_[1]),
4246
					  q{QUOTED_STRING},
4247
					  $tracelevel)
4248
						if defined $::RD_TRACE;
4249
		my $thisprod = $thisrule->{"prods"}[0];
4250
		$text = $_[1];
4251
		my $_savetext;
4252
		@item = (q{QUOTED_STRING});
4253
		%item = (__RULE__ => q{QUOTED_STRING});
4254
		my $repcount = 0;
4255
 
4256
 
4257
		Parse::RecDescent::_trace(q{Trying subrule: [DOUBLE_QUOTED_STRING]},
4258
				  Parse::RecDescent::_tracefirst($text),
4259
				  q{QUOTED_STRING},
4260
				  $tracelevel)
4261
					if defined $::RD_TRACE;
4262
		if (1) { no strict qw{refs};
4263
		$expectation->is(q{})->at($text);
4264
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::DOUBLE_QUOTED_STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4265
		{
4266
 
4267
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [DOUBLE_QUOTED_STRING]>>},
4268
						  Parse::RecDescent::_tracefirst($text),
4269
						  q{QUOTED_STRING},
4270
						  $tracelevel)
4271
							if defined $::RD_TRACE;
4272
			$expectation->failed();
4273
			last;
4274
		}
4275
		Parse::RecDescent::_trace(q{>>Matched subrule: [DOUBLE_QUOTED_STRING]<< (return value: [}
4276
					. $_tok . q{]},
4277
 
4278
					  Parse::RecDescent::_tracefirst($text),
4279
					  q{QUOTED_STRING},
4280
					  $tracelevel)
4281
						if defined $::RD_TRACE;
4282
		$item{q{DOUBLE_QUOTED_STRING}} = $_tok;
4283
		push @item, $_tok;
4284
 
4285
		}
4286
 
4287
 
4288
		Parse::RecDescent::_trace(q{>>Matched production: [DOUBLE_QUOTED_STRING]<<},
4289
					  Parse::RecDescent::_tracefirst($text),
4290
					  q{QUOTED_STRING},
4291
					  $tracelevel)
4292
						if defined $::RD_TRACE;
4293
		$_matched = 1;
4294
		last;
4295
	}
4296
 
4297
		splice
4298
				@{$thisparser->{deferred}}, $def_at unless $_matched;
4299
 
4300
	while (!$_matched && !$commit)
4301
	{
4302
 
4303
		Parse::RecDescent::_trace(q{Trying production: [SINGLE_QUOTED_STRING]},
4304
					  Parse::RecDescent::_tracefirst($_[1]),
4305
					  q{QUOTED_STRING},
4306
					  $tracelevel)
4307
						if defined $::RD_TRACE;
4308
		my $thisprod = $thisrule->{"prods"}[1];
4309
		$text = $_[1];
4310
		my $_savetext;
4311
		@item = (q{QUOTED_STRING});
4312
		%item = (__RULE__ => q{QUOTED_STRING});
4313
		my $repcount = 0;
4314
 
4315
 
4316
		Parse::RecDescent::_trace(q{Trying subrule: [SINGLE_QUOTED_STRING]},
4317
				  Parse::RecDescent::_tracefirst($text),
4318
				  q{QUOTED_STRING},
4319
				  $tracelevel)
4320
					if defined $::RD_TRACE;
4321
		if (1) { no strict qw{refs};
4322
		$expectation->is(q{})->at($text);
4323
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::SINGLE_QUOTED_STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4324
		{
4325
 
4326
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [SINGLE_QUOTED_STRING]>>},
4327
						  Parse::RecDescent::_tracefirst($text),
4328
						  q{QUOTED_STRING},
4329
						  $tracelevel)
4330
							if defined $::RD_TRACE;
4331
			$expectation->failed();
4332
			last;
4333
		}
4334
		Parse::RecDescent::_trace(q{>>Matched subrule: [SINGLE_QUOTED_STRING]<< (return value: [}
4335
					. $_tok . q{]},
4336
 
4337
					  Parse::RecDescent::_tracefirst($text),
4338
					  q{QUOTED_STRING},
4339
					  $tracelevel)
4340
						if defined $::RD_TRACE;
4341
		$item{q{SINGLE_QUOTED_STRING}} = $_tok;
4342
		push @item, $_tok;
4343
 
4344
		}
4345
 
4346
		Parse::RecDescent::_trace(q{Trying action},
4347
					  Parse::RecDescent::_tracefirst($text),
4348
					  q{QUOTED_STRING},
4349
					  $tracelevel)
4350
						if defined $::RD_TRACE;
4351
 
4352
 
4353
		$_tok = ($_noactions) ? 0 : do {
4354
 
4355
	 $return = $item{DOUBLE_QUOTED_STRING}||$item{SINGLE_QUOTED_STRING} ;
4356
	 $return||defined($return);
4357
};
4358
		unless (defined $_tok)
4359
		{
4360
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
4361
					if defined $::RD_TRACE;
4362
			last;
4363
		}
4364
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4365
					  . $_tok . q{])},
4366
					  Parse::RecDescent::_tracefirst($text))
4367
						if defined $::RD_TRACE;
4368
		push @item, $_tok;
4369
		$item{__ACTION1__}=$_tok;
4370
 
4371
 
4372
 
4373
		Parse::RecDescent::_trace(q{>>Matched production: [SINGLE_QUOTED_STRING]<<},
4374
					  Parse::RecDescent::_tracefirst($text),
4375
					  q{QUOTED_STRING},
4376
					  $tracelevel)
4377
						if defined $::RD_TRACE;
4378
		$_matched = 1;
4379
		last;
4380
	}
4381
 
4382
		splice
4383
				@{$thisparser->{deferred}}, $def_at unless $_matched;
4384
 
4385
        unless ( $_matched || defined($score) )
4386
	{
4387
				splice @{$thisparser->{deferred}}, $def_at;
4388
 
4389
 
4390
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
4391
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
4392
					 Parse::RecDescent::_tracefirst($_[1]),
4393
					 q{QUOTED_STRING},
4394
					 $tracelevel)
4395
					if defined $::RD_TRACE;
4396
		return undef;
4397
	}
4398
	if (!defined($return) && defined($score))
4399
	{
4400
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4401
					  q{QUOTED_STRING},
4402
					  $tracelevel)
4403
						if defined $::RD_TRACE;
4404
		$return = $score_return;
4405
	}
4406
	splice @{$thisparser->{errors}}, $err_at;
4407
	$return = $item[$#item] unless defined $return;
4408
	if (defined $::RD_TRACE)
4409
	{
4410
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4411
					  $return . q{])}, "",
4412
					  q{QUOTED_STRING},
4413
					  $tracelevel);
4414
		Parse::RecDescent::_trace(q{(consumed: [} .
4415
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
4416
					  Parse::RecDescent::_tracefirst($text),
4417
					  , q{QUOTED_STRING},
4418
					  $tracelevel)
4419
	}
4420
	$_[1] = $text;
4421
	return $return;
4422
}
4423
 
4424
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
4425
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::messagerfc822message
4426
{
4427
	my $thisparser = $_[0];
4428
	use vars q{$tracelevel};
4429
	local $tracelevel = ($tracelevel||0)+1;
4430
	$ERRORS = 0;
4431
	my $thisrule = $thisparser->{"rules"}{"messagerfc822message"};
4432
 
4433
	Parse::RecDescent::_trace(q{Trying rule: [messagerfc822message]},
4434
				  Parse::RecDescent::_tracefirst($_[1]),
4435
				  q{messagerfc822message},
4436
				  $tracelevel)
4437
					if defined $::RD_TRACE;
4438
 
4439
	my $def_at = @{$thisparser->{deferred}};
4440
	my $err_at = @{$thisparser->{errors}};
4441
 
4442
	my $score;
4443
	my $score_return;
4444
	my $_tok;
4445
	my $return = undef;
4446
	my $_matched=0;
4447
	my $commit=0;
4448
	my @item = ();
4449
	my %item = ();
4450
	my $repeating =  defined($_[2]) && $_[2];
4451
	my $_noactions = defined($_[3]) && $_[3];
4452
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
4453
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
4454
	my $text;
4455
	my $lastsep="";
4456
    my $expectation = new Parse::RecDescent::Expectation(q{rfc822message});
4457
	$expectation->at($_[1]);
4458
 
4459
	my $thisline;
4460
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4461
 
4462
 
4463
 
4464
	while (!$_matched && !$commit)
4465
	{
4466
 
4467
		Parse::RecDescent::_trace(q{Trying production: [rfc822message <commit> bodyparms bodyid bodydesc bodyenc bodysize envelopestruct bodystructure textlines bodyMD5 bodydisp bodylang]},
4468
					  Parse::RecDescent::_tracefirst($_[1]),
4469
					  q{messagerfc822message},
4470
					  $tracelevel)
4471
						if defined $::RD_TRACE;
4472
		my $thisprod = $thisrule->{"prods"}[0];
4473
		$text = $_[1];
4474
		my $_savetext;
4475
		@item = (q{messagerfc822message});
4476
		%item = (__RULE__ => q{messagerfc822message});
4477
		my $repcount = 0;
4478
 
4479
 
4480
		Parse::RecDescent::_trace(q{Trying subrule: [rfc822message]},
4481
				  Parse::RecDescent::_tracefirst($text),
4482
				  q{messagerfc822message},
4483
				  $tracelevel)
4484
					if defined $::RD_TRACE;
4485
		if (1) { no strict qw{refs};
4486
		$expectation->is(q{})->at($text);
4487
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::rfc822message($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4488
		{
4489
 
4490
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [rfc822message]>>},
4491
						  Parse::RecDescent::_tracefirst($text),
4492
						  q{messagerfc822message},
4493
						  $tracelevel)
4494
							if defined $::RD_TRACE;
4495
			$expectation->failed();
4496
			last;
4497
		}
4498
		Parse::RecDescent::_trace(q{>>Matched subrule: [rfc822message]<< (return value: [}
4499
					. $_tok . q{]},
4500
 
4501
					  Parse::RecDescent::_tracefirst($text),
4502
					  q{messagerfc822message},
4503
					  $tracelevel)
4504
						if defined $::RD_TRACE;
4505
		$item{q{rfc822message}} = $_tok;
4506
		push @item, $_tok;
4507
 
4508
		}
4509
 
4510
 
4511
 
4512
		Parse::RecDescent::_trace(q{Trying directive: [<commit>]},
4513
					Parse::RecDescent::_tracefirst($text),
4514
					  q{messagerfc822message},
4515
					  $tracelevel)
4516
						if defined $::RD_TRACE; 
4517
		$_tok = do { $commit = 1 };
4518
		if (defined($_tok))
4519
		{
4520
			Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
4521
						. $_tok . q{])},
4522
						Parse::RecDescent::_tracefirst($text))
4523
							if defined $::RD_TRACE;
4524
		}
4525
		else
4526
		{
4527
			Parse::RecDescent::_trace(q{<<Didn't match directive>>},
4528
						Parse::RecDescent::_tracefirst($text))
4529
							if defined $::RD_TRACE;
4530
		}
4531
 
4532
		last unless defined $_tok;
4533
		push @item, $item{__DIRECTIVE1__}=$_tok;
4534
 
4535
 
4536
		Parse::RecDescent::_trace(q{Trying subrule: [bodyparms]},
4537
				  Parse::RecDescent::_tracefirst($text),
4538
				  q{messagerfc822message},
4539
				  $tracelevel)
4540
					if defined $::RD_TRACE;
4541
		if (1) { no strict qw{refs};
4542
		$expectation->is(q{bodyparms})->at($text);
4543
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyparms($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4544
		{
4545
 
4546
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [bodyparms]>>},
4547
						  Parse::RecDescent::_tracefirst($text),
4548
						  q{messagerfc822message},
4549
						  $tracelevel)
4550
							if defined $::RD_TRACE;
4551
			$expectation->failed();
4552
			last;
4553
		}
4554
		Parse::RecDescent::_trace(q{>>Matched subrule: [bodyparms]<< (return value: [}
4555
					. $_tok . q{]},
4556
 
4557
					  Parse::RecDescent::_tracefirst($text),
4558
					  q{messagerfc822message},
4559
					  $tracelevel)
4560
						if defined $::RD_TRACE;
4561
		$item{q{bodyparms}} = $_tok;
4562
		push @item, $_tok;
4563
 
4564
		}
4565
 
4566
		Parse::RecDescent::_trace(q{Trying subrule: [bodyid]},
4567
				  Parse::RecDescent::_tracefirst($text),
4568
				  q{messagerfc822message},
4569
				  $tracelevel)
4570
					if defined $::RD_TRACE;
4571
		if (1) { no strict qw{refs};
4572
		$expectation->is(q{bodyid})->at($text);
4573
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyid($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4574
		{
4575
 
4576
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [bodyid]>>},
4577
						  Parse::RecDescent::_tracefirst($text),
4578
						  q{messagerfc822message},
4579
						  $tracelevel)
4580
							if defined $::RD_TRACE;
4581
			$expectation->failed();
4582
			last;
4583
		}
4584
		Parse::RecDescent::_trace(q{>>Matched subrule: [bodyid]<< (return value: [}
4585
					. $_tok . q{]},
4586
 
4587
					  Parse::RecDescent::_tracefirst($text),
4588
					  q{messagerfc822message},
4589
					  $tracelevel)
4590
						if defined $::RD_TRACE;
4591
		$item{q{bodyid}} = $_tok;
4592
		push @item, $_tok;
4593
 
4594
		}
4595
 
4596
		Parse::RecDescent::_trace(q{Trying subrule: [bodydesc]},
4597
				  Parse::RecDescent::_tracefirst($text),
4598
				  q{messagerfc822message},
4599
				  $tracelevel)
4600
					if defined $::RD_TRACE;
4601
		if (1) { no strict qw{refs};
4602
		$expectation->is(q{bodydesc})->at($text);
4603
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodydesc($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4604
		{
4605
 
4606
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [bodydesc]>>},
4607
						  Parse::RecDescent::_tracefirst($text),
4608
						  q{messagerfc822message},
4609
						  $tracelevel)
4610
							if defined $::RD_TRACE;
4611
			$expectation->failed();
4612
			last;
4613
		}
4614
		Parse::RecDescent::_trace(q{>>Matched subrule: [bodydesc]<< (return value: [}
4615
					. $_tok . q{]},
4616
 
4617
					  Parse::RecDescent::_tracefirst($text),
4618
					  q{messagerfc822message},
4619
					  $tracelevel)
4620
						if defined $::RD_TRACE;
4621
		$item{q{bodydesc}} = $_tok;
4622
		push @item, $_tok;
4623
 
4624
		}
4625
 
4626
		Parse::RecDescent::_trace(q{Trying subrule: [bodyenc]},
4627
				  Parse::RecDescent::_tracefirst($text),
4628
				  q{messagerfc822message},
4629
				  $tracelevel)
4630
					if defined $::RD_TRACE;
4631
		if (1) { no strict qw{refs};
4632
		$expectation->is(q{bodyenc})->at($text);
4633
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyenc($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4634
		{
4635
 
4636
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [bodyenc]>>},
4637
						  Parse::RecDescent::_tracefirst($text),
4638
						  q{messagerfc822message},
4639
						  $tracelevel)
4640
							if defined $::RD_TRACE;
4641
			$expectation->failed();
4642
			last;
4643
		}
4644
		Parse::RecDescent::_trace(q{>>Matched subrule: [bodyenc]<< (return value: [}
4645
					. $_tok . q{]},
4646
 
4647
					  Parse::RecDescent::_tracefirst($text),
4648
					  q{messagerfc822message},
4649
					  $tracelevel)
4650
						if defined $::RD_TRACE;
4651
		$item{q{bodyenc}} = $_tok;
4652
		push @item, $_tok;
4653
 
4654
		}
4655
 
4656
		Parse::RecDescent::_trace(q{Trying subrule: [bodysize]},
4657
				  Parse::RecDescent::_tracefirst($text),
4658
				  q{messagerfc822message},
4659
				  $tracelevel)
4660
					if defined $::RD_TRACE;
4661
		if (1) { no strict qw{refs};
4662
		$expectation->is(q{bodysize})->at($text);
4663
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodysize($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4664
		{
4665
 
4666
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [bodysize]>>},
4667
						  Parse::RecDescent::_tracefirst($text),
4668
						  q{messagerfc822message},
4669
						  $tracelevel)
4670
							if defined $::RD_TRACE;
4671
			$expectation->failed();
4672
			last;
4673
		}
4674
		Parse::RecDescent::_trace(q{>>Matched subrule: [bodysize]<< (return value: [}
4675
					. $_tok . q{]},
4676
 
4677
					  Parse::RecDescent::_tracefirst($text),
4678
					  q{messagerfc822message},
4679
					  $tracelevel)
4680
						if defined $::RD_TRACE;
4681
		$item{q{bodysize}} = $_tok;
4682
		push @item, $_tok;
4683
 
4684
		}
4685
 
4686
		Parse::RecDescent::_trace(q{Trying subrule: [envelopestruct]},
4687
				  Parse::RecDescent::_tracefirst($text),
4688
				  q{messagerfc822message},
4689
				  $tracelevel)
4690
					if defined $::RD_TRACE;
4691
		if (1) { no strict qw{refs};
4692
		$expectation->is(q{envelopestruct})->at($text);
4693
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::envelopestruct($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4694
		{
4695
 
4696
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [envelopestruct]>>},
4697
						  Parse::RecDescent::_tracefirst($text),
4698
						  q{messagerfc822message},
4699
						  $tracelevel)
4700
							if defined $::RD_TRACE;
4701
			$expectation->failed();
4702
			last;
4703
		}
4704
		Parse::RecDescent::_trace(q{>>Matched subrule: [envelopestruct]<< (return value: [}
4705
					. $_tok . q{]},
4706
 
4707
					  Parse::RecDescent::_tracefirst($text),
4708
					  q{messagerfc822message},
4709
					  $tracelevel)
4710
						if defined $::RD_TRACE;
4711
		$item{q{envelopestruct}} = $_tok;
4712
		push @item, $_tok;
4713
 
4714
		}
4715
 
4716
		Parse::RecDescent::_trace(q{Trying subrule: [bodystructure]},
4717
				  Parse::RecDescent::_tracefirst($text),
4718
				  q{messagerfc822message},
4719
				  $tracelevel)
4720
					if defined $::RD_TRACE;
4721
		if (1) { no strict qw{refs};
4722
		$expectation->is(q{bodystructure})->at($text);
4723
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodystructure($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4724
		{
4725
 
4726
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [bodystructure]>>},
4727
						  Parse::RecDescent::_tracefirst($text),
4728
						  q{messagerfc822message},
4729
						  $tracelevel)
4730
							if defined $::RD_TRACE;
4731
			$expectation->failed();
4732
			last;
4733
		}
4734
		Parse::RecDescent::_trace(q{>>Matched subrule: [bodystructure]<< (return value: [}
4735
					. $_tok . q{]},
4736
 
4737
					  Parse::RecDescent::_tracefirst($text),
4738
					  q{messagerfc822message},
4739
					  $tracelevel)
4740
						if defined $::RD_TRACE;
4741
		$item{q{bodystructure}} = $_tok;
4742
		push @item, $_tok;
4743
 
4744
		}
4745
 
4746
		Parse::RecDescent::_trace(q{Trying subrule: [textlines]},
4747
				  Parse::RecDescent::_tracefirst($text),
4748
				  q{messagerfc822message},
4749
				  $tracelevel)
4750
					if defined $::RD_TRACE;
4751
		if (1) { no strict qw{refs};
4752
		$expectation->is(q{textlines})->at($text);
4753
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::textlines($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4754
		{
4755
 
4756
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [textlines]>>},
4757
						  Parse::RecDescent::_tracefirst($text),
4758
						  q{messagerfc822message},
4759
						  $tracelevel)
4760
							if defined $::RD_TRACE;
4761
			$expectation->failed();
4762
			last;
4763
		}
4764
		Parse::RecDescent::_trace(q{>>Matched subrule: [textlines]<< (return value: [}
4765
					. $_tok . q{]},
4766
 
4767
					  Parse::RecDescent::_tracefirst($text),
4768
					  q{messagerfc822message},
4769
					  $tracelevel)
4770
						if defined $::RD_TRACE;
4771
		$item{q{textlines}} = $_tok;
4772
		push @item, $_tok;
4773
 
4774
		}
4775
 
4776
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodyMD5]},
4777
				  Parse::RecDescent::_tracefirst($text),
4778
				  q{messagerfc822message},
4779
				  $tracelevel)
4780
					if defined $::RD_TRACE;
4781
		$expectation->is(q{bodyMD5})->at($text);
4782
 
4783
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyMD5, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
4784
		{
4785
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodyMD5]>>},
4786
						  Parse::RecDescent::_tracefirst($text),
4787
						  q{messagerfc822message},
4788
						  $tracelevel)
4789
							if defined $::RD_TRACE;
4790
			last;
4791
		}
4792
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodyMD5]<< (}
4793
					. @$_tok . q{ times)},
4794
 
4795
					  Parse::RecDescent::_tracefirst($text),
4796
					  q{messagerfc822message},
4797
					  $tracelevel)
4798
						if defined $::RD_TRACE;
4799
		$item{q{bodyMD5(?)}} = $_tok;
4800
		push @item, $_tok;
4801
 
4802
 
4803
 
4804
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodydisp]},
4805
				  Parse::RecDescent::_tracefirst($text),
4806
				  q{messagerfc822message},
4807
				  $tracelevel)
4808
					if defined $::RD_TRACE;
4809
		$expectation->is(q{bodydisp})->at($text);
4810
 
4811
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodydisp, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
4812
		{
4813
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodydisp]>>},
4814
						  Parse::RecDescent::_tracefirst($text),
4815
						  q{messagerfc822message},
4816
						  $tracelevel)
4817
							if defined $::RD_TRACE;
4818
			last;
4819
		}
4820
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodydisp]<< (}
4821
					. @$_tok . q{ times)},
4822
 
4823
					  Parse::RecDescent::_tracefirst($text),
4824
					  q{messagerfc822message},
4825
					  $tracelevel)
4826
						if defined $::RD_TRACE;
4827
		$item{q{bodydisp(?)}} = $_tok;
4828
		push @item, $_tok;
4829
 
4830
 
4831
 
4832
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodylang]},
4833
				  Parse::RecDescent::_tracefirst($text),
4834
				  q{messagerfc822message},
4835
				  $tracelevel)
4836
					if defined $::RD_TRACE;
4837
		$expectation->is(q{bodylang})->at($text);
4838
 
4839
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodylang, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
4840
		{
4841
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodylang]>>},
4842
						  Parse::RecDescent::_tracefirst($text),
4843
						  q{messagerfc822message},
4844
						  $tracelevel)
4845
							if defined $::RD_TRACE;
4846
			last;
4847
		}
4848
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodylang]<< (}
4849
					. @$_tok . q{ times)},
4850
 
4851
					  Parse::RecDescent::_tracefirst($text),
4852
					  q{messagerfc822message},
4853
					  $tracelevel)
4854
						if defined $::RD_TRACE;
4855
		$item{q{bodylang(?)}} = $_tok;
4856
		push @item, $_tok;
4857
 
4858
 
4859
 
4860
		Parse::RecDescent::_trace(q{Trying action},
4861
					  Parse::RecDescent::_tracefirst($text),
4862
					  q{messagerfc822message},
4863
					  $tracelevel)
4864
						if defined $::RD_TRACE;
4865
 
4866
 
4867
		$_tok = ($_noactions) ? 0 : do { 
4868
	  $return = {}; 
4869
	  foreach my $what (qw/	bodyparms bodyid bodydesc bodyenc bodysize 
4870
				envelopestruct bodystructure textlines
4871
				bodyMD5(?) bodydisp(?) bodylang(?)
4872
	  		     /
4873
	  ) {
4874
		my $k = $what; $k =~ s/\(\?\)$//;
4875
                $return->{$k} = ref $item{$what} =~ 'ARRAY'?
4876
                                        $item{$what}[0] : $item{$what};
4877
        }
4878
        while ( my($k,$v) = each %{$item{bodystructure}[0]} ) { $return->{$k} = $v }
4879
        while ( my($k,$v) = each %{$item{basicfields}}   ) { $return->{$k} = $v }
4880
	$return->{bodytype} 	= "MESSAGE" ; 
4881
	$return->{bodysubtype}= "RFC822" ;
4882
	$return||defined($return);
4883
	};
4884
		unless (defined $_tok)
4885
		{
4886
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
4887
					if defined $::RD_TRACE;
4888
			last;
4889
		}
4890
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4891
					  . $_tok . q{])},
4892
					  Parse::RecDescent::_tracefirst($text))
4893
						if defined $::RD_TRACE;
4894
		push @item, $_tok;
4895
		$item{__ACTION1__}=$_tok;
4896
 
4897
 
4898
 
4899
		Parse::RecDescent::_trace(q{>>Matched production: [rfc822message <commit> bodyparms bodyid bodydesc bodyenc bodysize envelopestruct bodystructure textlines bodyMD5 bodydisp bodylang]<<},
4900
					  Parse::RecDescent::_tracefirst($text),
4901
					  q{messagerfc822message},
4902
					  $tracelevel)
4903
						if defined $::RD_TRACE;
4904
		$_matched = 1;
4905
		last;
4906
	}
4907
 
4908
		splice
4909
				@{$thisparser->{deferred}}, $def_at unless $_matched;
4910
 
4911
        unless ( $_matched || defined($score) )
4912
	{
4913
				splice @{$thisparser->{deferred}}, $def_at;
4914
 
4915
 
4916
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
4917
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
4918
					 Parse::RecDescent::_tracefirst($_[1]),
4919
					 q{messagerfc822message},
4920
					 $tracelevel)
4921
					if defined $::RD_TRACE;
4922
		return undef;
4923
	}
4924
	if (!defined($return) && defined($score))
4925
	{
4926
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4927
					  q{messagerfc822message},
4928
					  $tracelevel)
4929
						if defined $::RD_TRACE;
4930
		$return = $score_return;
4931
	}
4932
	splice @{$thisparser->{errors}}, $err_at;
4933
	$return = $item[$#item] unless defined $return;
4934
	if (defined $::RD_TRACE)
4935
	{
4936
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4937
					  $return . q{])}, "",
4938
					  q{messagerfc822message},
4939
					  $tracelevel);
4940
		Parse::RecDescent::_trace(q{(consumed: [} .
4941
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
4942
					  Parse::RecDescent::_tracefirst($text),
4943
					  , q{messagerfc822message},
4944
					  $tracelevel)
4945
	}
4946
	$_[1] = $text;
4947
	return $return;
4948
}
4949
 
4950
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
4951
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyenc
4952
{
4953
	my $thisparser = $_[0];
4954
	use vars q{$tracelevel};
4955
	local $tracelevel = ($tracelevel||0)+1;
4956
	$ERRORS = 0;
4957
	my $thisrule = $thisparser->{"rules"}{"bodyenc"};
4958
 
4959
	Parse::RecDescent::_trace(q{Trying rule: [bodyenc]},
4960
				  Parse::RecDescent::_tracefirst($_[1]),
4961
				  q{bodyenc},
4962
				  $tracelevel)
4963
					if defined $::RD_TRACE;
4964
 
4965
	my $def_at = @{$thisparser->{deferred}};
4966
	my $err_at = @{$thisparser->{errors}};
4967
 
4968
	my $score;
4969
	my $score_return;
4970
	my $_tok;
4971
	my $return = undef;
4972
	my $_matched=0;
4973
	my $commit=0;
4974
	my @item = ();
4975
	my %item = ();
4976
	my $repeating =  defined($_[2]) && $_[2];
4977
	my $_noactions = defined($_[3]) && $_[3];
4978
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
4979
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
4980
	my $text;
4981
	my $lastsep="";
4982
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or STRING, or '('});
4983
	$expectation->at($_[1]);
4984
 
4985
	my $thisline;
4986
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4987
 
4988
 
4989
 
4990
	while (!$_matched && !$commit)
4991
	{
4992
 
4993
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
4994
					  Parse::RecDescent::_tracefirst($_[1]),
4995
					  q{bodyenc},
4996
					  $tracelevel)
4997
						if defined $::RD_TRACE;
4998
		my $thisprod = $thisrule->{"prods"}[0];
4999
		$text = $_[1];
5000
		my $_savetext;
5001
		@item = (q{bodyenc});
5002
		%item = (__RULE__ => q{bodyenc});
5003
		my $repcount = 0;
5004
 
5005
 
5006
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
5007
				  Parse::RecDescent::_tracefirst($text),
5008
				  q{bodyenc},
5009
				  $tracelevel)
5010
					if defined $::RD_TRACE;
5011
		if (1) { no strict qw{refs};
5012
		$expectation->is(q{})->at($text);
5013
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5014
		{
5015
 
5016
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
5017
						  Parse::RecDescent::_tracefirst($text),
5018
						  q{bodyenc},
5019
						  $tracelevel)
5020
							if defined $::RD_TRACE;
5021
			$expectation->failed();
5022
			last;
5023
		}
5024
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
5025
					. $_tok . q{]},
5026
 
5027
					  Parse::RecDescent::_tracefirst($text),
5028
					  q{bodyenc},
5029
					  $tracelevel)
5030
						if defined $::RD_TRACE;
5031
		$item{q{NIL}} = $_tok;
5032
		push @item, $_tok;
5033
 
5034
		}
5035
 
5036
 
5037
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
5038
					  Parse::RecDescent::_tracefirst($text),
5039
					  q{bodyenc},
5040
					  $tracelevel)
5041
						if defined $::RD_TRACE;
5042
		$_matched = 1;
5043
		last;
5044
	}
5045
 
5046
		splice
5047
				@{$thisparser->{deferred}}, $def_at unless $_matched;
5048
 
5049
	while (!$_matched && !$commit)
5050
	{
5051
 
5052
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
5053
					  Parse::RecDescent::_tracefirst($_[1]),
5054
					  q{bodyenc},
5055
					  $tracelevel)
5056
						if defined $::RD_TRACE;
5057
		my $thisprod = $thisrule->{"prods"}[1];
5058
		$text = $_[1];
5059
		my $_savetext;
5060
		@item = (q{bodyenc});
5061
		%item = (__RULE__ => q{bodyenc});
5062
		my $repcount = 0;
5063
 
5064
 
5065
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
5066
				  Parse::RecDescent::_tracefirst($text),
5067
				  q{bodyenc},
5068
				  $tracelevel)
5069
					if defined $::RD_TRACE;
5070
		if (1) { no strict qw{refs};
5071
		$expectation->is(q{})->at($text);
5072
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5073
		{
5074
 
5075
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
5076
						  Parse::RecDescent::_tracefirst($text),
5077
						  q{bodyenc},
5078
						  $tracelevel)
5079
							if defined $::RD_TRACE;
5080
			$expectation->failed();
5081
			last;
5082
		}
5083
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
5084
					. $_tok . q{]},
5085
 
5086
					  Parse::RecDescent::_tracefirst($text),
5087
					  q{bodyenc},
5088
					  $tracelevel)
5089
						if defined $::RD_TRACE;
5090
		$item{q{STRING}} = $_tok;
5091
		push @item, $_tok;
5092
 
5093
		}
5094
 
5095
 
5096
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
5097
					  Parse::RecDescent::_tracefirst($text),
5098
					  q{bodyenc},
5099
					  $tracelevel)
5100
						if defined $::RD_TRACE;
5101
		$_matched = 1;
5102
		last;
5103
	}
5104
 
5105
		splice
5106
				@{$thisparser->{deferred}}, $def_at unless $_matched;
5107
 
5108
	while (!$_matched && !$commit)
5109
	{
5110
 
5111
		Parse::RecDescent::_trace(q{Trying production: ['(' kvpair ')']},
5112
					  Parse::RecDescent::_tracefirst($_[1]),
5113
					  q{bodyenc},
5114
					  $tracelevel)
5115
						if defined $::RD_TRACE;
5116
		my $thisprod = $thisrule->{"prods"}[2];
5117
		$text = $_[1];
5118
		my $_savetext;
5119
		@item = (q{bodyenc});
5120
		%item = (__RULE__ => q{bodyenc});
5121
		my $repcount = 0;
5122
 
5123
 
5124
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
5125
					  Parse::RecDescent::_tracefirst($text),
5126
					  q{bodyenc},
5127
					  $tracelevel)
5128
						if defined $::RD_TRACE;
5129
		$lastsep = "";
5130
		$expectation->is(q{})->at($text);
5131
 
5132
 
5133
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A\(//)
5134
		{
5135
 
5136
			$expectation->failed();
5137
			Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
5138
						  Parse::RecDescent::_tracefirst($text))
5139
							if defined $::RD_TRACE;
5140
			last;
5141
		}
5142
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
5143
						. $& . q{])},
5144
						  Parse::RecDescent::_tracefirst($text))
5145
							if defined $::RD_TRACE;
5146
		push @item, $item{__STRING1__}=$&;
5147
 
5148
 
5149
		Parse::RecDescent::_trace(q{Trying repeated subrule: [kvpair]},
5150
				  Parse::RecDescent::_tracefirst($text),
5151
				  q{bodyenc},
5152
				  $tracelevel)
5153
					if defined $::RD_TRACE;
5154
		$expectation->is(q{kvpair})->at($text);
5155
 
5156
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::kvpair, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
5157
		{
5158
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [kvpair]>>},
5159
						  Parse::RecDescent::_tracefirst($text),
5160
						  q{bodyenc},
5161
						  $tracelevel)
5162
							if defined $::RD_TRACE;
5163
			last;
5164
		}
5165
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [kvpair]<< (}
5166
					. @$_tok . q{ times)},
5167
 
5168
					  Parse::RecDescent::_tracefirst($text),
5169
					  q{bodyenc},
5170
					  $tracelevel)
5171
						if defined $::RD_TRACE;
5172
		$item{q{kvpair(s)}} = $_tok;
5173
		push @item, $_tok;
5174
 
5175
 
5176
 
5177
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
5178
					  Parse::RecDescent::_tracefirst($text),
5179
					  q{bodyenc},
5180
					  $tracelevel)
5181
						if defined $::RD_TRACE;
5182
		$lastsep = "";
5183
		$expectation->is(q{')'})->at($text);
5184
 
5185
 
5186
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A\)//)
5187
		{
5188
 
5189
			$expectation->failed();
5190
			Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
5191
						  Parse::RecDescent::_tracefirst($text))
5192
							if defined $::RD_TRACE;
5193
			last;
5194
		}
5195
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
5196
						. $& . q{])},
5197
						  Parse::RecDescent::_tracefirst($text))
5198
							if defined $::RD_TRACE;
5199
		push @item, $item{__STRING2__}=$&;
5200
 
5201
 
5202
		Parse::RecDescent::_trace(q{Trying action},
5203
					  Parse::RecDescent::_tracefirst($text),
5204
					  q{bodyenc},
5205
					  $tracelevel)
5206
						if defined $::RD_TRACE;
5207
 
5208
 
5209
		$_tok = ($_noactions) ? 0 : do {
5210
		$return = $item{NIL} 		|| 
5211
			  $item{STRING} 	||
5212
			  { map { (%$_) } @{$item{'kvpair(s)'}} };
5213
		$return||defined($return);
5214
	};
5215
		unless (defined $_tok)
5216
		{
5217
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
5218
					if defined $::RD_TRACE;
5219
			last;
5220
		}
5221
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5222
					  . $_tok . q{])},
5223
					  Parse::RecDescent::_tracefirst($text))
5224
						if defined $::RD_TRACE;
5225
		push @item, $_tok;
5226
		$item{__ACTION1__}=$_tok;
5227
 
5228
 
5229
 
5230
		Parse::RecDescent::_trace(q{>>Matched production: ['(' kvpair ')']<<},
5231
					  Parse::RecDescent::_tracefirst($text),
5232
					  q{bodyenc},
5233
					  $tracelevel)
5234
						if defined $::RD_TRACE;
5235
		$_matched = 1;
5236
		last;
5237
	}
5238
 
5239
		splice
5240
				@{$thisparser->{deferred}}, $def_at unless $_matched;
5241
 
5242
        unless ( $_matched || defined($score) )
5243
	{
5244
				splice @{$thisparser->{deferred}}, $def_at;
5245
 
5246
 
5247
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
5248
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
5249
					 Parse::RecDescent::_tracefirst($_[1]),
5250
					 q{bodyenc},
5251
					 $tracelevel)
5252
					if defined $::RD_TRACE;
5253
		return undef;
5254
	}
5255
	if (!defined($return) && defined($score))
5256
	{
5257
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5258
					  q{bodyenc},
5259
					  $tracelevel)
5260
						if defined $::RD_TRACE;
5261
		$return = $score_return;
5262
	}
5263
	splice @{$thisparser->{errors}}, $err_at;
5264
	$return = $item[$#item] unless defined $return;
5265
	if (defined $::RD_TRACE)
5266
	{
5267
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5268
					  $return . q{])}, "",
5269
					  q{bodyenc},
5270
					  $tracelevel);
5271
		Parse::RecDescent::_trace(q{(consumed: [} .
5272
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
5273
					  Parse::RecDescent::_tracefirst($text),
5274
					  , q{bodyenc},
5275
					  $tracelevel)
5276
	}
5277
	$_[1] = $text;
5278
	return $return;
5279
}
5280
 
5281
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5282
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodydesc
5283
{
5284
	my $thisparser = $_[0];
5285
	use vars q{$tracelevel};
5286
	local $tracelevel = ($tracelevel||0)+1;
5287
	$ERRORS = 0;
5288
	my $thisrule = $thisparser->{"rules"}{"bodydesc"};
5289
 
5290
	Parse::RecDescent::_trace(q{Trying rule: [bodydesc]},
5291
				  Parse::RecDescent::_tracefirst($_[1]),
5292
				  q{bodydesc},
5293
				  $tracelevel)
5294
					if defined $::RD_TRACE;
5295
 
5296
	my $def_at = @{$thisparser->{deferred}};
5297
	my $err_at = @{$thisparser->{errors}};
5298
 
5299
	my $score;
5300
	my $score_return;
5301
	my $_tok;
5302
	my $return = undef;
5303
	my $_matched=0;
5304
	my $commit=0;
5305
	my @item = ();
5306
	my %item = ();
5307
	my $repeating =  defined($_[2]) && $_[2];
5308
	my $_noactions = defined($_[3]) && $_[3];
5309
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
5310
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
5311
	my $text;
5312
	my $lastsep="";
5313
    my $expectation = new Parse::RecDescent::Expectation(q{/[()]/, or STRING});
5314
	$expectation->at($_[1]);
5315
 
5316
	my $thisline;
5317
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5318
 
5319
 
5320
 
5321
	while (!$_matched && !$commit)
5322
	{
5323
 
5324
		Parse::RecDescent::_trace(q{Trying production: [/[()]/ NIL]},
5325
					  Parse::RecDescent::_tracefirst($_[1]),
5326
					  q{bodydesc},
5327
					  $tracelevel)
5328
						if defined $::RD_TRACE;
5329
		my $thisprod = $thisrule->{"prods"}[0];
5330
		$text = $_[1];
5331
		my $_savetext;
5332
		@item = (q{bodydesc});
5333
		%item = (__RULE__ => q{bodydesc});
5334
		my $repcount = 0;
5335
 
5336
 
5337
		Parse::RecDescent::_trace(q{Trying terminal: [/[()]/]}, Parse::RecDescent::_tracefirst($text),
5338
					  q{bodydesc},
5339
					  $tracelevel)
5340
						if defined $::RD_TRACE;
5341
		$lastsep = "";
5342
		$expectation->is(q{})->at($text);
5343
		$_savetext = $text;
5344
 
5345
		if ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:[()])//)
5346
		{
5347
			$text = $_savetext;
5348
			$expectation->failed();
5349
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
5350
						  Parse::RecDescent::_tracefirst($text))
5351
					if defined $::RD_TRACE;
5352
 
5353
			last;
5354
		}
5355
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
5356
						. $& . q{])},
5357
						  Parse::RecDescent::_tracefirst($text))
5358
					if defined $::RD_TRACE;
5359
		push @item, $item{__PATTERN1__}=$&;
5360
		$text = $_savetext;
5361
 
5362
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
5363
				  Parse::RecDescent::_tracefirst($text),
5364
				  q{bodydesc},
5365
				  $tracelevel)
5366
					if defined $::RD_TRACE;
5367
		if (1) { no strict qw{refs};
5368
		$expectation->is(q{NIL})->at($text);
5369
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5370
		{
5371
 
5372
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
5373
						  Parse::RecDescent::_tracefirst($text),
5374
						  q{bodydesc},
5375
						  $tracelevel)
5376
							if defined $::RD_TRACE;
5377
			$expectation->failed();
5378
			last;
5379
		}
5380
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
5381
					. $_tok . q{]},
5382
 
5383
					  Parse::RecDescent::_tracefirst($text),
5384
					  q{bodydesc},
5385
					  $tracelevel)
5386
						if defined $::RD_TRACE;
5387
		$item{q{NIL}} = $_tok;
5388
		push @item, $_tok;
5389
 
5390
		}
5391
 
5392
 
5393
		Parse::RecDescent::_trace(q{>>Matched production: [/[()]/ NIL]<<},
5394
					  Parse::RecDescent::_tracefirst($text),
5395
					  q{bodydesc},
5396
					  $tracelevel)
5397
						if defined $::RD_TRACE;
5398
		$_matched = 1;
5399
		last;
5400
	}
5401
 
5402
		splice
5403
				@{$thisparser->{deferred}}, $def_at unless $_matched;
5404
 
5405
	while (!$_matched && !$commit)
5406
	{
5407
 
5408
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
5409
					  Parse::RecDescent::_tracefirst($_[1]),
5410
					  q{bodydesc},
5411
					  $tracelevel)
5412
						if defined $::RD_TRACE;
5413
		my $thisprod = $thisrule->{"prods"}[1];
5414
		$text = $_[1];
5415
		my $_savetext;
5416
		@item = (q{bodydesc});
5417
		%item = (__RULE__ => q{bodydesc});
5418
		my $repcount = 0;
5419
 
5420
 
5421
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
5422
				  Parse::RecDescent::_tracefirst($text),
5423
				  q{bodydesc},
5424
				  $tracelevel)
5425
					if defined $::RD_TRACE;
5426
		if (1) { no strict qw{refs};
5427
		$expectation->is(q{})->at($text);
5428
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5429
		{
5430
 
5431
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
5432
						  Parse::RecDescent::_tracefirst($text),
5433
						  q{bodydesc},
5434
						  $tracelevel)
5435
							if defined $::RD_TRACE;
5436
			$expectation->failed();
5437
			last;
5438
		}
5439
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
5440
					. $_tok . q{]},
5441
 
5442
					  Parse::RecDescent::_tracefirst($text),
5443
					  q{bodydesc},
5444
					  $tracelevel)
5445
						if defined $::RD_TRACE;
5446
		$item{q{STRING}} = $_tok;
5447
		push @item, $_tok;
5448
 
5449
		}
5450
 
5451
		Parse::RecDescent::_trace(q{Trying action},
5452
					  Parse::RecDescent::_tracefirst($text),
5453
					  q{bodydesc},
5454
					  $tracelevel)
5455
						if defined $::RD_TRACE;
5456
 
5457
 
5458
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{STRING} ; $return||defined($return);};
5459
		unless (defined $_tok)
5460
		{
5461
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
5462
					if defined $::RD_TRACE;
5463
			last;
5464
		}
5465
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5466
					  . $_tok . q{])},
5467
					  Parse::RecDescent::_tracefirst($text))
5468
						if defined $::RD_TRACE;
5469
		push @item, $_tok;
5470
		$item{__ACTION1__}=$_tok;
5471
 
5472
 
5473
 
5474
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
5475
					  Parse::RecDescent::_tracefirst($text),
5476
					  q{bodydesc},
5477
					  $tracelevel)
5478
						if defined $::RD_TRACE;
5479
		$_matched = 1;
5480
		last;
5481
	}
5482
 
5483
		splice
5484
				@{$thisparser->{deferred}}, $def_at unless $_matched;
5485
 
5486
        unless ( $_matched || defined($score) )
5487
	{
5488
				splice @{$thisparser->{deferred}}, $def_at;
5489
 
5490
 
5491
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
5492
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
5493
					 Parse::RecDescent::_tracefirst($_[1]),
5494
					 q{bodydesc},
5495
					 $tracelevel)
5496
					if defined $::RD_TRACE;
5497
		return undef;
5498
	}
5499
	if (!defined($return) && defined($score))
5500
	{
5501
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5502
					  q{bodydesc},
5503
					  $tracelevel)
5504
						if defined $::RD_TRACE;
5505
		$return = $score_return;
5506
	}
5507
	splice @{$thisparser->{errors}}, $err_at;
5508
	$return = $item[$#item] unless defined $return;
5509
	if (defined $::RD_TRACE)
5510
	{
5511
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5512
					  $return . q{])}, "",
5513
					  q{bodydesc},
5514
					  $tracelevel);
5515
		Parse::RecDescent::_trace(q{(consumed: [} .
5516
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
5517
					  Parse::RecDescent::_tracefirst($text),
5518
					  , q{bodydesc},
5519
					  $tracelevel)
5520
	}
5521
	$_[1] = $text;
5522
	return $return;
5523
}
5524
 
5525
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5526
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::start
5527
{
5528
	my $thisparser = $_[0];
5529
	use vars q{$tracelevel};
5530
	local $tracelevel = ($tracelevel||0)+1;
5531
	$ERRORS = 0;
5532
	my $thisrule = $thisparser->{"rules"}{"start"};
5533
 
5534
	Parse::RecDescent::_trace(q{Trying rule: [start]},
5535
				  Parse::RecDescent::_tracefirst($_[1]),
5536
				  q{start},
5537
				  $tracelevel)
5538
					if defined $::RD_TRACE;
5539
 
5540
	my $def_at = @{$thisparser->{deferred}};
5541
	my $err_at = @{$thisparser->{errors}};
5542
 
5543
	my $score;
5544
	my $score_return;
5545
	my $_tok;
5546
	my $return = undef;
5547
	my $_matched=0;
5548
	my $commit=0;
5549
	my @item = ();
5550
	my %item = ();
5551
	my $repeating =  defined($_[2]) && $_[2];
5552
	my $_noactions = defined($_[3]) && $_[3];
5553
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
5554
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
5555
	my $text;
5556
	my $lastsep="";
5557
    my $expectation = new Parse::RecDescent::Expectation(q{/.*\\(.*BODYSTRUCTURE \\(/i});
5558
	$expectation->at($_[1]);
5559
 
5560
	my $thisline;
5561
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5562
 
5563
 
5564
 
5565
	while (!$_matched && !$commit)
5566
	{
5567
 
5568
		Parse::RecDescent::_trace(q{Trying production: [/.*\\(.*BODYSTRUCTURE \\(/i part /\\).*\\)\\r?\\n?/]},
5569
					  Parse::RecDescent::_tracefirst($_[1]),
5570
					  q{start},
5571
					  $tracelevel)
5572
						if defined $::RD_TRACE;
5573
		my $thisprod = $thisrule->{"prods"}[0];
5574
		$text = $_[1];
5575
		my $_savetext;
5576
		@item = (q{start});
5577
		%item = (__RULE__ => q{start});
5578
		my $repcount = 0;
5579
 
5580
 
5581
		Parse::RecDescent::_trace(q{Trying terminal: [/.*\\(.*BODYSTRUCTURE \\(/i]}, Parse::RecDescent::_tracefirst($text),
5582
					  q{start},
5583
					  $tracelevel)
5584
						if defined $::RD_TRACE;
5585
		$lastsep = "";
5586
		$expectation->is(q{})->at($text);
5587
 
5588
 
5589
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:.*\(.*BODYSTRUCTURE \()//i)
5590
		{
5591
 
5592
			$expectation->failed();
5593
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
5594
						  Parse::RecDescent::_tracefirst($text))
5595
					if defined $::RD_TRACE;
5596
 
5597
			last;
5598
		}
5599
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
5600
						. $& . q{])},
5601
						  Parse::RecDescent::_tracefirst($text))
5602
					if defined $::RD_TRACE;
5603
		push @item, $item{__PATTERN1__}=$&;
5604
 
5605
 
5606
		Parse::RecDescent::_trace(q{Trying repeated subrule: [part]},
5607
				  Parse::RecDescent::_tracefirst($text),
5608
				  q{start},
5609
				  $tracelevel)
5610
					if defined $::RD_TRACE;
5611
		$expectation->is(q{part})->at($text);
5612
 
5613
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::part, 1, 1, $_noactions,$expectation,sub { \@arg }))) 
5614
		{
5615
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [part]>>},
5616
						  Parse::RecDescent::_tracefirst($text),
5617
						  q{start},
5618
						  $tracelevel)
5619
							if defined $::RD_TRACE;
5620
			last;
5621
		}
5622
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [part]<< (}
5623
					. @$_tok . q{ times)},
5624
 
5625
					  Parse::RecDescent::_tracefirst($text),
5626
					  q{start},
5627
					  $tracelevel)
5628
						if defined $::RD_TRACE;
5629
		$item{q{part(1)}} = $_tok;
5630
		push @item, $_tok;
5631
 
5632
 
5633
 
5634
		Parse::RecDescent::_trace(q{Trying terminal: [/\\).*\\)\\r?\\n?/]}, Parse::RecDescent::_tracefirst($text),
5635
					  q{start},
5636
					  $tracelevel)
5637
						if defined $::RD_TRACE;
5638
		$lastsep = "";
5639
		$expectation->is(q{/\\).*\\)\\r?\\n?/})->at($text);
5640
 
5641
 
5642
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:\).*\)\r?\n?)//)
5643
		{
5644
 
5645
			$expectation->failed();
5646
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
5647
						  Parse::RecDescent::_tracefirst($text))
5648
					if defined $::RD_TRACE;
5649
 
5650
			last;
5651
		}
5652
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
5653
						. $& . q{])},
5654
						  Parse::RecDescent::_tracefirst($text))
5655
					if defined $::RD_TRACE;
5656
		push @item, $item{__PATTERN2__}=$&;
5657
 
5658
 
5659
		Parse::RecDescent::_trace(q{Trying action},
5660
					  Parse::RecDescent::_tracefirst($text),
5661
					  q{start},
5662
					  $tracelevel)
5663
						if defined $::RD_TRACE;
5664
 
5665
 
5666
		$_tok = ($_noactions) ? 0 : do {
5667
			#print STDERR "item = ",Data::Dumper->Dump([\%item],['$item']);
5668
			$return = $item{'part(1)'}[0];
5669
			$return||defined($return);
5670
		};
5671
		unless (defined $_tok)
5672
		{
5673
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
5674
					if defined $::RD_TRACE;
5675
			last;
5676
		}
5677
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5678
					  . $_tok . q{])},
5679
					  Parse::RecDescent::_tracefirst($text))
5680
						if defined $::RD_TRACE;
5681
		push @item, $_tok;
5682
		$item{__ACTION1__}=$_tok;
5683
 
5684
 
5685
 
5686
		Parse::RecDescent::_trace(q{>>Matched production: [/.*\\(.*BODYSTRUCTURE \\(/i part /\\).*\\)\\r?\\n?/]<<},
5687
					  Parse::RecDescent::_tracefirst($text),
5688
					  q{start},
5689
					  $tracelevel)
5690
						if defined $::RD_TRACE;
5691
		$_matched = 1;
5692
		last;
5693
	}
5694
 
5695
		splice
5696
				@{$thisparser->{deferred}}, $def_at unless $_matched;
5697
 
5698
        unless ( $_matched || defined($score) )
5699
	{
5700
				splice @{$thisparser->{deferred}}, $def_at;
5701
 
5702
 
5703
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
5704
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
5705
					 Parse::RecDescent::_tracefirst($_[1]),
5706
					 q{start},
5707
					 $tracelevel)
5708
					if defined $::RD_TRACE;
5709
		return undef;
5710
	}
5711
	if (!defined($return) && defined($score))
5712
	{
5713
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5714
					  q{start},
5715
					  $tracelevel)
5716
						if defined $::RD_TRACE;
5717
		$return = $score_return;
5718
	}
5719
	splice @{$thisparser->{errors}}, $err_at;
5720
	$return = $item[$#item] unless defined $return;
5721
	if (defined $::RD_TRACE)
5722
	{
5723
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5724
					  $return . q{])}, "",
5725
					  q{start},
5726
					  $tracelevel);
5727
		Parse::RecDescent::_trace(q{(consumed: [} .
5728
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
5729
					  Parse::RecDescent::_tracefirst($text),
5730
					  , q{start},
5731
					  $tracelevel)
5732
	}
5733
	$_[1] = $text;
5734
	return $return;
5735
}
5736
 
5737
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5738
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::RFC822
5739
{
5740
	my $thisparser = $_[0];
5741
	use vars q{$tracelevel};
5742
	local $tracelevel = ($tracelevel||0)+1;
5743
	$ERRORS = 0;
5744
	my $thisrule = $thisparser->{"rules"}{"RFC822"};
5745
 
5746
	Parse::RecDescent::_trace(q{Trying rule: [RFC822]},
5747
				  Parse::RecDescent::_tracefirst($_[1]),
5748
				  q{RFC822},
5749
				  $tracelevel)
5750
					if defined $::RD_TRACE;
5751
 
5752
	my $def_at = @{$thisparser->{deferred}};
5753
	my $err_at = @{$thisparser->{errors}};
5754
 
5755
	my $score;
5756
	my $score_return;
5757
	my $_tok;
5758
	my $return = undef;
5759
	my $_matched=0;
5760
	my $commit=0;
5761
	my @item = ();
5762
	my %item = ();
5763
	my $repeating =  defined($_[2]) && $_[2];
5764
	my $_noactions = defined($_[3]) && $_[3];
5765
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
5766
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
5767
	my $text;
5768
	my $lastsep="";
5769
    my $expectation = new Parse::RecDescent::Expectation(q{/^"RFC822"|^RFC822/i});
5770
	$expectation->at($_[1]);
5771
 
5772
	my $thisline;
5773
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5774
 
5775
 
5776
 
5777
	while (!$_matched && !$commit)
5778
	{
5779
 
5780
		Parse::RecDescent::_trace(q{Trying production: [/^"RFC822"|^RFC822/i]},
5781
					  Parse::RecDescent::_tracefirst($_[1]),
5782
					  q{RFC822},
5783
					  $tracelevel)
5784
						if defined $::RD_TRACE;
5785
		my $thisprod = $thisrule->{"prods"}[0];
5786
		$text = $_[1];
5787
		my $_savetext;
5788
		@item = (q{RFC822});
5789
		%item = (__RULE__ => q{RFC822});
5790
		my $repcount = 0;
5791
 
5792
 
5793
		Parse::RecDescent::_trace(q{Trying terminal: [/^"RFC822"|^RFC822/i]}, Parse::RecDescent::_tracefirst($text),
5794
					  q{RFC822},
5795
					  $tracelevel)
5796
						if defined $::RD_TRACE;
5797
		$lastsep = "";
5798
		$expectation->is(q{})->at($text);
5799
 
5800
 
5801
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:^"RFC822"|^RFC822)//i)
5802
		{
5803
 
5804
			$expectation->failed();
5805
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
5806
						  Parse::RecDescent::_tracefirst($text))
5807
					if defined $::RD_TRACE;
5808
 
5809
			last;
5810
		}
5811
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
5812
						. $& . q{])},
5813
						  Parse::RecDescent::_tracefirst($text))
5814
					if defined $::RD_TRACE;
5815
		push @item, $item{__PATTERN1__}=$&;
5816
 
5817
 
5818
		Parse::RecDescent::_trace(q{Trying action},
5819
					  Parse::RecDescent::_tracefirst($text),
5820
					  q{RFC822},
5821
					  $tracelevel)
5822
						if defined $::RD_TRACE;
5823
 
5824
 
5825
		$_tok = ($_noactions) ? 0 : do { $return = "RFC822" 	};
5826
		unless (defined $_tok)
5827
		{
5828
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
5829
					if defined $::RD_TRACE;
5830
			last;
5831
		}
5832
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5833
					  . $_tok . q{])},
5834
					  Parse::RecDescent::_tracefirst($text))
5835
						if defined $::RD_TRACE;
5836
		push @item, $_tok;
5837
		$item{__ACTION1__}=$_tok;
5838
 
5839
 
5840
 
5841
		Parse::RecDescent::_trace(q{>>Matched production: [/^"RFC822"|^RFC822/i]<<},
5842
					  Parse::RecDescent::_tracefirst($text),
5843
					  q{RFC822},
5844
					  $tracelevel)
5845
						if defined $::RD_TRACE;
5846
		$_matched = 1;
5847
		last;
5848
	}
5849
 
5850
		splice
5851
				@{$thisparser->{deferred}}, $def_at unless $_matched;
5852
 
5853
        unless ( $_matched || defined($score) )
5854
	{
5855
				splice @{$thisparser->{deferred}}, $def_at;
5856
 
5857
 
5858
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
5859
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
5860
					 Parse::RecDescent::_tracefirst($_[1]),
5861
					 q{RFC822},
5862
					 $tracelevel)
5863
					if defined $::RD_TRACE;
5864
		return undef;
5865
	}
5866
	if (!defined($return) && defined($score))
5867
	{
5868
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5869
					  q{RFC822},
5870
					  $tracelevel)
5871
						if defined $::RD_TRACE;
5872
		$return = $score_return;
5873
	}
5874
	splice @{$thisparser->{errors}}, $err_at;
5875
	$return = $item[$#item] unless defined $return;
5876
	if (defined $::RD_TRACE)
5877
	{
5878
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5879
					  $return . q{])}, "",
5880
					  q{RFC822},
5881
					  $tracelevel);
5882
		Parse::RecDescent::_trace(q{(consumed: [} .
5883
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
5884
					  Parse::RecDescent::_tracefirst($text),
5885
					  , q{RFC822},
5886
					  $tracelevel)
5887
	}
5888
	$_[1] = $text;
5889
	return $return;
5890
}
5891
 
5892
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5893
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::textmessage
5894
{
5895
	my $thisparser = $_[0];
5896
	use vars q{$tracelevel};
5897
	local $tracelevel = ($tracelevel||0)+1;
5898
	$ERRORS = 0;
5899
	my $thisrule = $thisparser->{"rules"}{"textmessage"};
5900
 
5901
	Parse::RecDescent::_trace(q{Trying rule: [textmessage]},
5902
				  Parse::RecDescent::_tracefirst($_[1]),
5903
				  q{textmessage},
5904
				  $tracelevel)
5905
					if defined $::RD_TRACE;
5906
 
5907
	my $def_at = @{$thisparser->{deferred}};
5908
	my $err_at = @{$thisparser->{errors}};
5909
 
5910
	my $score;
5911
	my $score_return;
5912
	my $_tok;
5913
	my $return = undef;
5914
	my $_matched=0;
5915
	my $commit=0;
5916
	my @item = ();
5917
	my %item = ();
5918
	my $repeating =  defined($_[2]) && $_[2];
5919
	my $_noactions = defined($_[3]) && $_[3];
5920
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
5921
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
5922
	my $text;
5923
	my $lastsep="";
5924
    my $expectation = new Parse::RecDescent::Expectation(q{TEXT});
5925
	$expectation->at($_[1]);
5926
 
5927
	my $thisline;
5928
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5929
 
5930
 
5931
 
5932
	while (!$_matched && !$commit)
5933
	{
5934
 
5935
		Parse::RecDescent::_trace(q{Trying production: [TEXT <commit> basicfields textlines bodyMD5 bodydisp bodylang]},
5936
					  Parse::RecDescent::_tracefirst($_[1]),
5937
					  q{textmessage},
5938
					  $tracelevel)
5939
						if defined $::RD_TRACE;
5940
		my $thisprod = $thisrule->{"prods"}[0];
5941
		$text = $_[1];
5942
		my $_savetext;
5943
		@item = (q{textmessage});
5944
		%item = (__RULE__ => q{textmessage});
5945
		my $repcount = 0;
5946
 
5947
 
5948
		Parse::RecDescent::_trace(q{Trying subrule: [TEXT]},
5949
				  Parse::RecDescent::_tracefirst($text),
5950
				  q{textmessage},
5951
				  $tracelevel)
5952
					if defined $::RD_TRACE;
5953
		if (1) { no strict qw{refs};
5954
		$expectation->is(q{})->at($text);
5955
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::TEXT($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5956
		{
5957
 
5958
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [TEXT]>>},
5959
						  Parse::RecDescent::_tracefirst($text),
5960
						  q{textmessage},
5961
						  $tracelevel)
5962
							if defined $::RD_TRACE;
5963
			$expectation->failed();
5964
			last;
5965
		}
5966
		Parse::RecDescent::_trace(q{>>Matched subrule: [TEXT]<< (return value: [}
5967
					. $_tok . q{]},
5968
 
5969
					  Parse::RecDescent::_tracefirst($text),
5970
					  q{textmessage},
5971
					  $tracelevel)
5972
						if defined $::RD_TRACE;
5973
		$item{q{TEXT}} = $_tok;
5974
		push @item, $_tok;
5975
 
5976
		}
5977
 
5978
 
5979
 
5980
		Parse::RecDescent::_trace(q{Trying directive: [<commit>]},
5981
					Parse::RecDescent::_tracefirst($text),
5982
					  q{textmessage},
5983
					  $tracelevel)
5984
						if defined $::RD_TRACE; 
5985
		$_tok = do { $commit = 1 };
5986
		if (defined($_tok))
5987
		{
5988
			Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
5989
						. $_tok . q{])},
5990
						Parse::RecDescent::_tracefirst($text))
5991
							if defined $::RD_TRACE;
5992
		}
5993
		else
5994
		{
5995
			Parse::RecDescent::_trace(q{<<Didn't match directive>>},
5996
						Parse::RecDescent::_tracefirst($text))
5997
							if defined $::RD_TRACE;
5998
		}
5999
 
6000
		last unless defined $_tok;
6001
		push @item, $item{__DIRECTIVE1__}=$_tok;
6002
 
6003
 
6004
		Parse::RecDescent::_trace(q{Trying subrule: [basicfields]},
6005
				  Parse::RecDescent::_tracefirst($text),
6006
				  q{textmessage},
6007
				  $tracelevel)
6008
					if defined $::RD_TRACE;
6009
		if (1) { no strict qw{refs};
6010
		$expectation->is(q{basicfields})->at($text);
6011
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::basicfields($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6012
		{
6013
 
6014
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [basicfields]>>},
6015
						  Parse::RecDescent::_tracefirst($text),
6016
						  q{textmessage},
6017
						  $tracelevel)
6018
							if defined $::RD_TRACE;
6019
			$expectation->failed();
6020
			last;
6021
		}
6022
		Parse::RecDescent::_trace(q{>>Matched subrule: [basicfields]<< (return value: [}
6023
					. $_tok . q{]},
6024
 
6025
					  Parse::RecDescent::_tracefirst($text),
6026
					  q{textmessage},
6027
					  $tracelevel)
6028
						if defined $::RD_TRACE;
6029
		$item{q{basicfields}} = $_tok;
6030
		push @item, $_tok;
6031
 
6032
		}
6033
 
6034
		Parse::RecDescent::_trace(q{Trying repeated subrule: [textlines]},
6035
				  Parse::RecDescent::_tracefirst($text),
6036
				  q{textmessage},
6037
				  $tracelevel)
6038
					if defined $::RD_TRACE;
6039
		$expectation->is(q{textlines})->at($text);
6040
 
6041
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::textlines, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
6042
		{
6043
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [textlines]>>},
6044
						  Parse::RecDescent::_tracefirst($text),
6045
						  q{textmessage},
6046
						  $tracelevel)
6047
							if defined $::RD_TRACE;
6048
			last;
6049
		}
6050
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [textlines]<< (}
6051
					. @$_tok . q{ times)},
6052
 
6053
					  Parse::RecDescent::_tracefirst($text),
6054
					  q{textmessage},
6055
					  $tracelevel)
6056
						if defined $::RD_TRACE;
6057
		$item{q{textlines(?)}} = $_tok;
6058
		push @item, $_tok;
6059
 
6060
 
6061
 
6062
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodyMD5]},
6063
				  Parse::RecDescent::_tracefirst($text),
6064
				  q{textmessage},
6065
				  $tracelevel)
6066
					if defined $::RD_TRACE;
6067
		$expectation->is(q{bodyMD5})->at($text);
6068
 
6069
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyMD5, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
6070
		{
6071
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodyMD5]>>},
6072
						  Parse::RecDescent::_tracefirst($text),
6073
						  q{textmessage},
6074
						  $tracelevel)
6075
							if defined $::RD_TRACE;
6076
			last;
6077
		}
6078
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodyMD5]<< (}
6079
					. @$_tok . q{ times)},
6080
 
6081
					  Parse::RecDescent::_tracefirst($text),
6082
					  q{textmessage},
6083
					  $tracelevel)
6084
						if defined $::RD_TRACE;
6085
		$item{q{bodyMD5(?)}} = $_tok;
6086
		push @item, $_tok;
6087
 
6088
 
6089
 
6090
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodydisp]},
6091
				  Parse::RecDescent::_tracefirst($text),
6092
				  q{textmessage},
6093
				  $tracelevel)
6094
					if defined $::RD_TRACE;
6095
		$expectation->is(q{bodydisp})->at($text);
6096
 
6097
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodydisp, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
6098
		{
6099
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodydisp]>>},
6100
						  Parse::RecDescent::_tracefirst($text),
6101
						  q{textmessage},
6102
						  $tracelevel)
6103
							if defined $::RD_TRACE;
6104
			last;
6105
		}
6106
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodydisp]<< (}
6107
					. @$_tok . q{ times)},
6108
 
6109
					  Parse::RecDescent::_tracefirst($text),
6110
					  q{textmessage},
6111
					  $tracelevel)
6112
						if defined $::RD_TRACE;
6113
		$item{q{bodydisp(?)}} = $_tok;
6114
		push @item, $_tok;
6115
 
6116
 
6117
 
6118
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodylang]},
6119
				  Parse::RecDescent::_tracefirst($text),
6120
				  q{textmessage},
6121
				  $tracelevel)
6122
					if defined $::RD_TRACE;
6123
		$expectation->is(q{bodylang})->at($text);
6124
 
6125
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodylang, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
6126
		{
6127
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodylang]>>},
6128
						  Parse::RecDescent::_tracefirst($text),
6129
						  q{textmessage},
6130
						  $tracelevel)
6131
							if defined $::RD_TRACE;
6132
			last;
6133
		}
6134
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodylang]<< (}
6135
					. @$_tok . q{ times)},
6136
 
6137
					  Parse::RecDescent::_tracefirst($text),
6138
					  q{textmessage},
6139
					  $tracelevel)
6140
						if defined $::RD_TRACE;
6141
		$item{q{bodylang(?)}} = $_tok;
6142
		push @item, $_tok;
6143
 
6144
 
6145
 
6146
		Parse::RecDescent::_trace(q{Trying action},
6147
					  Parse::RecDescent::_tracefirst($text),
6148
					  q{textmessage},
6149
					  $tracelevel)
6150
						if defined $::RD_TRACE;
6151
 
6152
 
6153
		$_tok = ($_noactions) ? 0 : do { 
6154
	  $return = $item{basicfields}||{};
6155
	  $return->{bodytype} = 'TEXT';
6156
	  foreach my $what (qw/textlines(?) bodyMD5(?) bodydisp(?) bodylang(?)/) {
6157
		my $k = $what; $k =~ s/\(\?\)$//;
6158
		ref($item{$what}) and $return->{$k} = $item{$what}[0];
6159
	  }
6160
	  $return||defined($return);
6161
        };
6162
		unless (defined $_tok)
6163
		{
6164
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
6165
					if defined $::RD_TRACE;
6166
			last;
6167
		}
6168
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
6169
					  . $_tok . q{])},
6170
					  Parse::RecDescent::_tracefirst($text))
6171
						if defined $::RD_TRACE;
6172
		push @item, $_tok;
6173
		$item{__ACTION1__}=$_tok;
6174
 
6175
 
6176
 
6177
		Parse::RecDescent::_trace(q{>>Matched production: [TEXT <commit> basicfields textlines bodyMD5 bodydisp bodylang]<<},
6178
					  Parse::RecDescent::_tracefirst($text),
6179
					  q{textmessage},
6180
					  $tracelevel)
6181
						if defined $::RD_TRACE;
6182
		$_matched = 1;
6183
		last;
6184
	}
6185
 
6186
		splice
6187
				@{$thisparser->{deferred}}, $def_at unless $_matched;
6188
 
6189
        unless ( $_matched || defined($score) )
6190
	{
6191
				splice @{$thisparser->{deferred}}, $def_at;
6192
 
6193
 
6194
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
6195
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
6196
					 Parse::RecDescent::_tracefirst($_[1]),
6197
					 q{textmessage},
6198
					 $tracelevel)
6199
					if defined $::RD_TRACE;
6200
		return undef;
6201
	}
6202
	if (!defined($return) && defined($score))
6203
	{
6204
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
6205
					  q{textmessage},
6206
					  $tracelevel)
6207
						if defined $::RD_TRACE;
6208
		$return = $score_return;
6209
	}
6210
	splice @{$thisparser->{errors}}, $err_at;
6211
	$return = $item[$#item] unless defined $return;
6212
	if (defined $::RD_TRACE)
6213
	{
6214
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
6215
					  $return . q{])}, "",
6216
					  q{textmessage},
6217
					  $tracelevel);
6218
		Parse::RecDescent::_trace(q{(consumed: [} .
6219
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
6220
					  Parse::RecDescent::_tracefirst($text),
6221
					  , q{textmessage},
6222
					  $tracelevel)
6223
	}
6224
	$_[1] = $text;
6225
	return $return;
6226
}
6227
 
6228
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
6229
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyid
6230
{
6231
	my $thisparser = $_[0];
6232
	use vars q{$tracelevel};
6233
	local $tracelevel = ($tracelevel||0)+1;
6234
	$ERRORS = 0;
6235
	my $thisrule = $thisparser->{"rules"}{"bodyid"};
6236
 
6237
	Parse::RecDescent::_trace(q{Trying rule: [bodyid]},
6238
				  Parse::RecDescent::_tracefirst($_[1]),
6239
				  q{bodyid},
6240
				  $tracelevel)
6241
					if defined $::RD_TRACE;
6242
 
6243
	my $def_at = @{$thisparser->{deferred}};
6244
	my $err_at = @{$thisparser->{errors}};
6245
 
6246
	my $score;
6247
	my $score_return;
6248
	my $_tok;
6249
	my $return = undef;
6250
	my $_matched=0;
6251
	my $commit=0;
6252
	my @item = ();
6253
	my %item = ();
6254
	my $repeating =  defined($_[2]) && $_[2];
6255
	my $_noactions = defined($_[3]) && $_[3];
6256
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
6257
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
6258
	my $text;
6259
	my $lastsep="";
6260
    my $expectation = new Parse::RecDescent::Expectation(q{/[()]/, or STRING});
6261
	$expectation->at($_[1]);
6262
 
6263
	my $thisline;
6264
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
6265
 
6266
 
6267
 
6268
	while (!$_matched && !$commit)
6269
	{
6270
 
6271
		Parse::RecDescent::_trace(q{Trying production: [/[()]/ NIL]},
6272
					  Parse::RecDescent::_tracefirst($_[1]),
6273
					  q{bodyid},
6274
					  $tracelevel)
6275
						if defined $::RD_TRACE;
6276
		my $thisprod = $thisrule->{"prods"}[0];
6277
		$text = $_[1];
6278
		my $_savetext;
6279
		@item = (q{bodyid});
6280
		%item = (__RULE__ => q{bodyid});
6281
		my $repcount = 0;
6282
 
6283
 
6284
		Parse::RecDescent::_trace(q{Trying terminal: [/[()]/]}, Parse::RecDescent::_tracefirst($text),
6285
					  q{bodyid},
6286
					  $tracelevel)
6287
						if defined $::RD_TRACE;
6288
		$lastsep = "";
6289
		$expectation->is(q{})->at($text);
6290
		$_savetext = $text;
6291
 
6292
		if ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:[()])//)
6293
		{
6294
			$text = $_savetext;
6295
			$expectation->failed();
6296
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
6297
						  Parse::RecDescent::_tracefirst($text))
6298
					if defined $::RD_TRACE;
6299
 
6300
			last;
6301
		}
6302
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
6303
						. $& . q{])},
6304
						  Parse::RecDescent::_tracefirst($text))
6305
					if defined $::RD_TRACE;
6306
		push @item, $item{__PATTERN1__}=$&;
6307
		$text = $_savetext;
6308
 
6309
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
6310
				  Parse::RecDescent::_tracefirst($text),
6311
				  q{bodyid},
6312
				  $tracelevel)
6313
					if defined $::RD_TRACE;
6314
		if (1) { no strict qw{refs};
6315
		$expectation->is(q{NIL})->at($text);
6316
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6317
		{
6318
 
6319
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
6320
						  Parse::RecDescent::_tracefirst($text),
6321
						  q{bodyid},
6322
						  $tracelevel)
6323
							if defined $::RD_TRACE;
6324
			$expectation->failed();
6325
			last;
6326
		}
6327
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
6328
					. $_tok . q{]},
6329
 
6330
					  Parse::RecDescent::_tracefirst($text),
6331
					  q{bodyid},
6332
					  $tracelevel)
6333
						if defined $::RD_TRACE;
6334
		$item{q{NIL}} = $_tok;
6335
		push @item, $_tok;
6336
 
6337
		}
6338
 
6339
 
6340
		Parse::RecDescent::_trace(q{>>Matched production: [/[()]/ NIL]<<},
6341
					  Parse::RecDescent::_tracefirst($text),
6342
					  q{bodyid},
6343
					  $tracelevel)
6344
						if defined $::RD_TRACE;
6345
		$_matched = 1;
6346
		last;
6347
	}
6348
 
6349
		splice
6350
				@{$thisparser->{deferred}}, $def_at unless $_matched;
6351
 
6352
	while (!$_matched && !$commit)
6353
	{
6354
 
6355
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
6356
					  Parse::RecDescent::_tracefirst($_[1]),
6357
					  q{bodyid},
6358
					  $tracelevel)
6359
						if defined $::RD_TRACE;
6360
		my $thisprod = $thisrule->{"prods"}[1];
6361
		$text = $_[1];
6362
		my $_savetext;
6363
		@item = (q{bodyid});
6364
		%item = (__RULE__ => q{bodyid});
6365
		my $repcount = 0;
6366
 
6367
 
6368
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
6369
				  Parse::RecDescent::_tracefirst($text),
6370
				  q{bodyid},
6371
				  $tracelevel)
6372
					if defined $::RD_TRACE;
6373
		if (1) { no strict qw{refs};
6374
		$expectation->is(q{})->at($text);
6375
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6376
		{
6377
 
6378
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
6379
						  Parse::RecDescent::_tracefirst($text),
6380
						  q{bodyid},
6381
						  $tracelevel)
6382
							if defined $::RD_TRACE;
6383
			$expectation->failed();
6384
			last;
6385
		}
6386
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
6387
					. $_tok . q{]},
6388
 
6389
					  Parse::RecDescent::_tracefirst($text),
6390
					  q{bodyid},
6391
					  $tracelevel)
6392
						if defined $::RD_TRACE;
6393
		$item{q{STRING}} = $_tok;
6394
		push @item, $_tok;
6395
 
6396
		}
6397
 
6398
		Parse::RecDescent::_trace(q{Trying action},
6399
					  Parse::RecDescent::_tracefirst($text),
6400
					  q{bodyid},
6401
					  $tracelevel)
6402
						if defined $::RD_TRACE;
6403
 
6404
 
6405
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{STRING} ; $return||defined($return);};
6406
		unless (defined $_tok)
6407
		{
6408
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
6409
					if defined $::RD_TRACE;
6410
			last;
6411
		}
6412
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
6413
					  . $_tok . q{])},
6414
					  Parse::RecDescent::_tracefirst($text))
6415
						if defined $::RD_TRACE;
6416
		push @item, $_tok;
6417
		$item{__ACTION1__}=$_tok;
6418
 
6419
 
6420
 
6421
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
6422
					  Parse::RecDescent::_tracefirst($text),
6423
					  q{bodyid},
6424
					  $tracelevel)
6425
						if defined $::RD_TRACE;
6426
		$_matched = 1;
6427
		last;
6428
	}
6429
 
6430
		splice
6431
				@{$thisparser->{deferred}}, $def_at unless $_matched;
6432
 
6433
        unless ( $_matched || defined($score) )
6434
	{
6435
				splice @{$thisparser->{deferred}}, $def_at;
6436
 
6437
 
6438
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
6439
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
6440
					 Parse::RecDescent::_tracefirst($_[1]),
6441
					 q{bodyid},
6442
					 $tracelevel)
6443
					if defined $::RD_TRACE;
6444
		return undef;
6445
	}
6446
	if (!defined($return) && defined($score))
6447
	{
6448
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
6449
					  q{bodyid},
6450
					  $tracelevel)
6451
						if defined $::RD_TRACE;
6452
		$return = $score_return;
6453
	}
6454
	splice @{$thisparser->{errors}}, $err_at;
6455
	$return = $item[$#item] unless defined $return;
6456
	if (defined $::RD_TRACE)
6457
	{
6458
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
6459
					  $return . q{])}, "",
6460
					  q{bodyid},
6461
					  $tracelevel);
6462
		Parse::RecDescent::_trace(q{(consumed: [} .
6463
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
6464
					  Parse::RecDescent::_tracefirst($text),
6465
					  , q{bodyid},
6466
					  $tracelevel)
6467
	}
6468
	$_[1] = $text;
6469
	return $return;
6470
}
6471
 
6472
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
6473
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::othertypemessage
6474
{
6475
	my $thisparser = $_[0];
6476
	use vars q{$tracelevel};
6477
	local $tracelevel = ($tracelevel||0)+1;
6478
	$ERRORS = 0;
6479
	my $thisrule = $thisparser->{"rules"}{"othertypemessage"};
6480
 
6481
	Parse::RecDescent::_trace(q{Trying rule: [othertypemessage]},
6482
				  Parse::RecDescent::_tracefirst($_[1]),
6483
				  q{othertypemessage},
6484
				  $tracelevel)
6485
					if defined $::RD_TRACE;
6486
 
6487
	my $def_at = @{$thisparser->{deferred}};
6488
	my $err_at = @{$thisparser->{errors}};
6489
 
6490
	my $score;
6491
	my $score_return;
6492
	my $_tok;
6493
	my $return = undef;
6494
	my $_matched=0;
6495
	my $commit=0;
6496
	my @item = ();
6497
	my %item = ();
6498
	my $repeating =  defined($_[2]) && $_[2];
6499
	my $_noactions = defined($_[3]) && $_[3];
6500
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
6501
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
6502
	my $text;
6503
	my $lastsep="";
6504
    my $expectation = new Parse::RecDescent::Expectation(q{bodytype});
6505
	$expectation->at($_[1]);
6506
 
6507
	my $thisline;
6508
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
6509
 
6510
 
6511
 
6512
	while (!$_matched && !$commit)
6513
	{
6514
 
6515
		Parse::RecDescent::_trace(q{Trying production: [bodytype basicfields bodyparms bodydisp bodylang]},
6516
					  Parse::RecDescent::_tracefirst($_[1]),
6517
					  q{othertypemessage},
6518
					  $tracelevel)
6519
						if defined $::RD_TRACE;
6520
		my $thisprod = $thisrule->{"prods"}[0];
6521
		$text = $_[1];
6522
		my $_savetext;
6523
		@item = (q{othertypemessage});
6524
		%item = (__RULE__ => q{othertypemessage});
6525
		my $repcount = 0;
6526
 
6527
 
6528
		Parse::RecDescent::_trace(q{Trying subrule: [bodytype]},
6529
				  Parse::RecDescent::_tracefirst($text),
6530
				  q{othertypemessage},
6531
				  $tracelevel)
6532
					if defined $::RD_TRACE;
6533
		if (1) { no strict qw{refs};
6534
		$expectation->is(q{})->at($text);
6535
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodytype($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6536
		{
6537
 
6538
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [bodytype]>>},
6539
						  Parse::RecDescent::_tracefirst($text),
6540
						  q{othertypemessage},
6541
						  $tracelevel)
6542
							if defined $::RD_TRACE;
6543
			$expectation->failed();
6544
			last;
6545
		}
6546
		Parse::RecDescent::_trace(q{>>Matched subrule: [bodytype]<< (return value: [}
6547
					. $_tok . q{]},
6548
 
6549
					  Parse::RecDescent::_tracefirst($text),
6550
					  q{othertypemessage},
6551
					  $tracelevel)
6552
						if defined $::RD_TRACE;
6553
		$item{q{bodytype}} = $_tok;
6554
		push @item, $_tok;
6555
 
6556
		}
6557
 
6558
		Parse::RecDescent::_trace(q{Trying subrule: [basicfields]},
6559
				  Parse::RecDescent::_tracefirst($text),
6560
				  q{othertypemessage},
6561
				  $tracelevel)
6562
					if defined $::RD_TRACE;
6563
		if (1) { no strict qw{refs};
6564
		$expectation->is(q{basicfields})->at($text);
6565
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::basicfields($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6566
		{
6567
 
6568
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [basicfields]>>},
6569
						  Parse::RecDescent::_tracefirst($text),
6570
						  q{othertypemessage},
6571
						  $tracelevel)
6572
							if defined $::RD_TRACE;
6573
			$expectation->failed();
6574
			last;
6575
		}
6576
		Parse::RecDescent::_trace(q{>>Matched subrule: [basicfields]<< (return value: [}
6577
					. $_tok . q{]},
6578
 
6579
					  Parse::RecDescent::_tracefirst($text),
6580
					  q{othertypemessage},
6581
					  $tracelevel)
6582
						if defined $::RD_TRACE;
6583
		$item{q{basicfields}} = $_tok;
6584
		push @item, $_tok;
6585
 
6586
		}
6587
 
6588
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodyparms]},
6589
				  Parse::RecDescent::_tracefirst($text),
6590
				  q{othertypemessage},
6591
				  $tracelevel)
6592
					if defined $::RD_TRACE;
6593
		$expectation->is(q{bodyparms})->at($text);
6594
 
6595
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyparms, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
6596
		{
6597
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodyparms]>>},
6598
						  Parse::RecDescent::_tracefirst($text),
6599
						  q{othertypemessage},
6600
						  $tracelevel)
6601
							if defined $::RD_TRACE;
6602
			last;
6603
		}
6604
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodyparms]<< (}
6605
					. @$_tok . q{ times)},
6606
 
6607
					  Parse::RecDescent::_tracefirst($text),
6608
					  q{othertypemessage},
6609
					  $tracelevel)
6610
						if defined $::RD_TRACE;
6611
		$item{q{bodyparms(?)}} = $_tok;
6612
		push @item, $_tok;
6613
 
6614
 
6615
 
6616
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodydisp]},
6617
				  Parse::RecDescent::_tracefirst($text),
6618
				  q{othertypemessage},
6619
				  $tracelevel)
6620
					if defined $::RD_TRACE;
6621
		$expectation->is(q{bodydisp})->at($text);
6622
 
6623
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodydisp, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
6624
		{
6625
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodydisp]>>},
6626
						  Parse::RecDescent::_tracefirst($text),
6627
						  q{othertypemessage},
6628
						  $tracelevel)
6629
							if defined $::RD_TRACE;
6630
			last;
6631
		}
6632
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodydisp]<< (}
6633
					. @$_tok . q{ times)},
6634
 
6635
					  Parse::RecDescent::_tracefirst($text),
6636
					  q{othertypemessage},
6637
					  $tracelevel)
6638
						if defined $::RD_TRACE;
6639
		$item{q{bodydisp(?)}} = $_tok;
6640
		push @item, $_tok;
6641
 
6642
 
6643
 
6644
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodylang]},
6645
				  Parse::RecDescent::_tracefirst($text),
6646
				  q{othertypemessage},
6647
				  $tracelevel)
6648
					if defined $::RD_TRACE;
6649
		$expectation->is(q{bodylang})->at($text);
6650
 
6651
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodylang, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
6652
		{
6653
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodylang]>>},
6654
						  Parse::RecDescent::_tracefirst($text),
6655
						  q{othertypemessage},
6656
						  $tracelevel)
6657
							if defined $::RD_TRACE;
6658
			last;
6659
		}
6660
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodylang]<< (}
6661
					. @$_tok . q{ times)},
6662
 
6663
					  Parse::RecDescent::_tracefirst($text),
6664
					  q{othertypemessage},
6665
					  $tracelevel)
6666
						if defined $::RD_TRACE;
6667
		$item{q{bodylang(?)}} = $_tok;
6668
		push @item, $_tok;
6669
 
6670
 
6671
 
6672
		Parse::RecDescent::_trace(q{Trying action},
6673
					  Parse::RecDescent::_tracefirst($text),
6674
					  q{othertypemessage},
6675
					  $tracelevel)
6676
						if defined $::RD_TRACE;
6677
 
6678
 
6679
		$_tok = ($_noactions) ? 0 : do { $return = {}; 
6680
	  foreach my $what (qw/bodytype bodyparms(?) bodydisp(?) bodylang(?)/) {
6681
		my $k = $what; $k =~ s/\(\?\)$//;
6682
		$return->{$k} = ref($item{$what})? $item{$what}[0] : $item{$what} ;
6683
	  }
6684
	  while ( my($k,$v) = each %{$item{basicfields}} ) { $return->{$k} = $v }
6685
	  $return||defined($return);
6686
	};
6687
		unless (defined $_tok)
6688
		{
6689
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
6690
					if defined $::RD_TRACE;
6691
			last;
6692
		}
6693
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
6694
					  . $_tok . q{])},
6695
					  Parse::RecDescent::_tracefirst($text))
6696
						if defined $::RD_TRACE;
6697
		push @item, $_tok;
6698
		$item{__ACTION1__}=$_tok;
6699
 
6700
 
6701
 
6702
		Parse::RecDescent::_trace(q{>>Matched production: [bodytype basicfields bodyparms bodydisp bodylang]<<},
6703
					  Parse::RecDescent::_tracefirst($text),
6704
					  q{othertypemessage},
6705
					  $tracelevel)
6706
						if defined $::RD_TRACE;
6707
		$_matched = 1;
6708
		last;
6709
	}
6710
 
6711
		splice
6712
				@{$thisparser->{deferred}}, $def_at unless $_matched;
6713
 
6714
        unless ( $_matched || defined($score) )
6715
	{
6716
				splice @{$thisparser->{deferred}}, $def_at;
6717
 
6718
 
6719
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
6720
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
6721
					 Parse::RecDescent::_tracefirst($_[1]),
6722
					 q{othertypemessage},
6723
					 $tracelevel)
6724
					if defined $::RD_TRACE;
6725
		return undef;
6726
	}
6727
	if (!defined($return) && defined($score))
6728
	{
6729
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
6730
					  q{othertypemessage},
6731
					  $tracelevel)
6732
						if defined $::RD_TRACE;
6733
		$return = $score_return;
6734
	}
6735
	splice @{$thisparser->{errors}}, $err_at;
6736
	$return = $item[$#item] unless defined $return;
6737
	if (defined $::RD_TRACE)
6738
	{
6739
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
6740
					  $return . q{])}, "",
6741
					  q{othertypemessage},
6742
					  $tracelevel);
6743
		Parse::RecDescent::_trace(q{(consumed: [} .
6744
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
6745
					  Parse::RecDescent::_tracefirst($text),
6746
					  , q{othertypemessage},
6747
					  $tracelevel)
6748
	}
6749
	$_[1] = $text;
6750
	return $return;
6751
}
6752
 
6753
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
6754
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::kvpair
6755
{
6756
	my $thisparser = $_[0];
6757
	use vars q{$tracelevel};
6758
	local $tracelevel = ($tracelevel||0)+1;
6759
	$ERRORS = 0;
6760
	my $thisrule = $thisparser->{"rules"}{"kvpair"};
6761
 
6762
	Parse::RecDescent::_trace(q{Trying rule: [kvpair]},
6763
				  Parse::RecDescent::_tracefirst($_[1]),
6764
				  q{kvpair},
6765
				  $tracelevel)
6766
					if defined $::RD_TRACE;
6767
 
6768
	my $def_at = @{$thisparser->{deferred}};
6769
	my $err_at = @{$thisparser->{errors}};
6770
 
6771
	my $score;
6772
	my $score_return;
6773
	my $_tok;
6774
	my $return = undef;
6775
	my $_matched=0;
6776
	my $commit=0;
6777
	my @item = ();
6778
	my %item = ();
6779
	my $repeating =  defined($_[2]) && $_[2];
6780
	my $_noactions = defined($_[3]) && $_[3];
6781
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
6782
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
6783
	my $text;
6784
	my $lastsep="";
6785
    my $expectation = new Parse::RecDescent::Expectation(q{')'});
6786
	$expectation->at($_[1]);
6787
 
6788
	my $thisline;
6789
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
6790
 
6791
 
6792
 
6793
	while (!$_matched && !$commit)
6794
	{
6795
 
6796
		Parse::RecDescent::_trace(q{Trying production: [')' key value]},
6797
					  Parse::RecDescent::_tracefirst($_[1]),
6798
					  q{kvpair},
6799
					  $tracelevel)
6800
						if defined $::RD_TRACE;
6801
		my $thisprod = $thisrule->{"prods"}[0];
6802
		$text = $_[1];
6803
		my $_savetext;
6804
		@item = (q{kvpair});
6805
		%item = (__RULE__ => q{kvpair});
6806
		my $repcount = 0;
6807
 
6808
 
6809
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
6810
					  Parse::RecDescent::_tracefirst($text),
6811
					  q{kvpair},
6812
					  $tracelevel)
6813
						if defined $::RD_TRACE;
6814
		$lastsep = "";
6815
		$expectation->is(q{})->at($text);
6816
		$_savetext = $text;
6817
 
6818
		if ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
6819
		     substr($text,0,length($_tok)) eq $_tok and
6820
		     do { substr($text,0,length($_tok)) = ""; 1; }
6821
		)
6822
		{
6823
			$text = $_savetext;
6824
			$expectation->failed();
6825
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
6826
						  Parse::RecDescent::_tracefirst($text))
6827
							if defined $::RD_TRACE;
6828
			last;
6829
		}
6830
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
6831
						. $_tok . q{])},
6832
						  Parse::RecDescent::_tracefirst($text))
6833
							if defined $::RD_TRACE;
6834
		push @item, $item{__STRING1__}=$_tok;
6835
		$text = $_savetext;
6836
 
6837
		Parse::RecDescent::_trace(q{Trying subrule: [key]},
6838
				  Parse::RecDescent::_tracefirst($text),
6839
				  q{kvpair},
6840
				  $tracelevel)
6841
					if defined $::RD_TRACE;
6842
		if (1) { no strict qw{refs};
6843
		$expectation->is(q{key})->at($text);
6844
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::key($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6845
		{
6846
 
6847
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [key]>>},
6848
						  Parse::RecDescent::_tracefirst($text),
6849
						  q{kvpair},
6850
						  $tracelevel)
6851
							if defined $::RD_TRACE;
6852
			$expectation->failed();
6853
			last;
6854
		}
6855
		Parse::RecDescent::_trace(q{>>Matched subrule: [key]<< (return value: [}
6856
					. $_tok . q{]},
6857
 
6858
					  Parse::RecDescent::_tracefirst($text),
6859
					  q{kvpair},
6860
					  $tracelevel)
6861
						if defined $::RD_TRACE;
6862
		$item{q{key}} = $_tok;
6863
		push @item, $_tok;
6864
 
6865
		}
6866
 
6867
		Parse::RecDescent::_trace(q{Trying subrule: [value]},
6868
				  Parse::RecDescent::_tracefirst($text),
6869
				  q{kvpair},
6870
				  $tracelevel)
6871
					if defined $::RD_TRACE;
6872
		if (1) { no strict qw{refs};
6873
		$expectation->is(q{value})->at($text);
6874
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::value($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6875
		{
6876
 
6877
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [value]>>},
6878
						  Parse::RecDescent::_tracefirst($text),
6879
						  q{kvpair},
6880
						  $tracelevel)
6881
							if defined $::RD_TRACE;
6882
			$expectation->failed();
6883
			last;
6884
		}
6885
		Parse::RecDescent::_trace(q{>>Matched subrule: [value]<< (return value: [}
6886
					. $_tok . q{]},
6887
 
6888
					  Parse::RecDescent::_tracefirst($text),
6889
					  q{kvpair},
6890
					  $tracelevel)
6891
						if defined $::RD_TRACE;
6892
		$item{q{value}} = $_tok;
6893
		push @item, $_tok;
6894
 
6895
		}
6896
 
6897
		Parse::RecDescent::_trace(q{Trying action},
6898
					  Parse::RecDescent::_tracefirst($text),
6899
					  q{kvpair},
6900
					  $tracelevel)
6901
						if defined $::RD_TRACE;
6902
 
6903
 
6904
		$_tok = ($_noactions) ? 0 : do { $return = { $item{key} => $item{value} }; $return||defined($return);};
6905
		unless (defined $_tok)
6906
		{
6907
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
6908
					if defined $::RD_TRACE;
6909
			last;
6910
		}
6911
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
6912
					  . $_tok . q{])},
6913
					  Parse::RecDescent::_tracefirst($text))
6914
						if defined $::RD_TRACE;
6915
		push @item, $_tok;
6916
		$item{__ACTION1__}=$_tok;
6917
 
6918
 
6919
 
6920
		Parse::RecDescent::_trace(q{>>Matched production: [')' key value]<<},
6921
					  Parse::RecDescent::_tracefirst($text),
6922
					  q{kvpair},
6923
					  $tracelevel)
6924
						if defined $::RD_TRACE;
6925
		$_matched = 1;
6926
		last;
6927
	}
6928
 
6929
		splice
6930
				@{$thisparser->{deferred}}, $def_at unless $_matched;
6931
 
6932
        unless ( $_matched || defined($score) )
6933
	{
6934
				splice @{$thisparser->{deferred}}, $def_at;
6935
 
6936
 
6937
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
6938
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
6939
					 Parse::RecDescent::_tracefirst($_[1]),
6940
					 q{kvpair},
6941
					 $tracelevel)
6942
					if defined $::RD_TRACE;
6943
		return undef;
6944
	}
6945
	if (!defined($return) && defined($score))
6946
	{
6947
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
6948
					  q{kvpair},
6949
					  $tracelevel)
6950
						if defined $::RD_TRACE;
6951
		$return = $score_return;
6952
	}
6953
	splice @{$thisparser->{errors}}, $err_at;
6954
	$return = $item[$#item] unless defined $return;
6955
	if (defined $::RD_TRACE)
6956
	{
6957
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
6958
					  $return . q{])}, "",
6959
					  q{kvpair},
6960
					  $tracelevel);
6961
		Parse::RecDescent::_trace(q{(consumed: [} .
6962
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
6963
					  Parse::RecDescent::_tracefirst($text),
6964
					  , q{kvpair},
6965
					  $tracelevel)
6966
	}
6967
	$_[1] = $text;
6968
	return $return;
6969
}
6970
 
6971
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
6972
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodysize
6973
{
6974
	my $thisparser = $_[0];
6975
	use vars q{$tracelevel};
6976
	local $tracelevel = ($tracelevel||0)+1;
6977
	$ERRORS = 0;
6978
	my $thisrule = $thisparser->{"rules"}{"bodysize"};
6979
 
6980
	Parse::RecDescent::_trace(q{Trying rule: [bodysize]},
6981
				  Parse::RecDescent::_tracefirst($_[1]),
6982
				  q{bodysize},
6983
				  $tracelevel)
6984
					if defined $::RD_TRACE;
6985
 
6986
	my $def_at = @{$thisparser->{deferred}};
6987
	my $err_at = @{$thisparser->{errors}};
6988
 
6989
	my $score;
6990
	my $score_return;
6991
	my $_tok;
6992
	my $return = undef;
6993
	my $_matched=0;
6994
	my $commit=0;
6995
	my @item = ();
6996
	my %item = ();
6997
	my $repeating =  defined($_[2]) && $_[2];
6998
	my $_noactions = defined($_[3]) && $_[3];
6999
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
7000
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
7001
	my $text;
7002
	my $lastsep="";
7003
    my $expectation = new Parse::RecDescent::Expectation(q{/[()]/, or NUMBER});
7004
	$expectation->at($_[1]);
7005
 
7006
	my $thisline;
7007
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
7008
 
7009
 
7010
 
7011
	while (!$_matched && !$commit)
7012
	{
7013
 
7014
		Parse::RecDescent::_trace(q{Trying production: [/[()]/ NIL]},
7015
					  Parse::RecDescent::_tracefirst($_[1]),
7016
					  q{bodysize},
7017
					  $tracelevel)
7018
						if defined $::RD_TRACE;
7019
		my $thisprod = $thisrule->{"prods"}[0];
7020
		$text = $_[1];
7021
		my $_savetext;
7022
		@item = (q{bodysize});
7023
		%item = (__RULE__ => q{bodysize});
7024
		my $repcount = 0;
7025
 
7026
 
7027
		Parse::RecDescent::_trace(q{Trying terminal: [/[()]/]}, Parse::RecDescent::_tracefirst($text),
7028
					  q{bodysize},
7029
					  $tracelevel)
7030
						if defined $::RD_TRACE;
7031
		$lastsep = "";
7032
		$expectation->is(q{})->at($text);
7033
		$_savetext = $text;
7034
 
7035
		if ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:[()])//)
7036
		{
7037
			$text = $_savetext;
7038
			$expectation->failed();
7039
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7040
						  Parse::RecDescent::_tracefirst($text))
7041
					if defined $::RD_TRACE;
7042
 
7043
			last;
7044
		}
7045
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7046
						. $& . q{])},
7047
						  Parse::RecDescent::_tracefirst($text))
7048
					if defined $::RD_TRACE;
7049
		push @item, $item{__PATTERN1__}=$&;
7050
		$text = $_savetext;
7051
 
7052
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
7053
				  Parse::RecDescent::_tracefirst($text),
7054
				  q{bodysize},
7055
				  $tracelevel)
7056
					if defined $::RD_TRACE;
7057
		if (1) { no strict qw{refs};
7058
		$expectation->is(q{NIL})->at($text);
7059
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
7060
		{
7061
 
7062
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
7063
						  Parse::RecDescent::_tracefirst($text),
7064
						  q{bodysize},
7065
						  $tracelevel)
7066
							if defined $::RD_TRACE;
7067
			$expectation->failed();
7068
			last;
7069
		}
7070
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
7071
					. $_tok . q{]},
7072
 
7073
					  Parse::RecDescent::_tracefirst($text),
7074
					  q{bodysize},
7075
					  $tracelevel)
7076
						if defined $::RD_TRACE;
7077
		$item{q{NIL}} = $_tok;
7078
		push @item, $_tok;
7079
 
7080
		}
7081
 
7082
 
7083
		Parse::RecDescent::_trace(q{>>Matched production: [/[()]/ NIL]<<},
7084
					  Parse::RecDescent::_tracefirst($text),
7085
					  q{bodysize},
7086
					  $tracelevel)
7087
						if defined $::RD_TRACE;
7088
		$_matched = 1;
7089
		last;
7090
	}
7091
 
7092
		splice
7093
				@{$thisparser->{deferred}}, $def_at unless $_matched;
7094
 
7095
	while (!$_matched && !$commit)
7096
	{
7097
 
7098
		Parse::RecDescent::_trace(q{Trying production: [NUMBER]},
7099
					  Parse::RecDescent::_tracefirst($_[1]),
7100
					  q{bodysize},
7101
					  $tracelevel)
7102
						if defined $::RD_TRACE;
7103
		my $thisprod = $thisrule->{"prods"}[1];
7104
		$text = $_[1];
7105
		my $_savetext;
7106
		@item = (q{bodysize});
7107
		%item = (__RULE__ => q{bodysize});
7108
		my $repcount = 0;
7109
 
7110
 
7111
		Parse::RecDescent::_trace(q{Trying subrule: [NUMBER]},
7112
				  Parse::RecDescent::_tracefirst($text),
7113
				  q{bodysize},
7114
				  $tracelevel)
7115
					if defined $::RD_TRACE;
7116
		if (1) { no strict qw{refs};
7117
		$expectation->is(q{})->at($text);
7118
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NUMBER($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
7119
		{
7120
 
7121
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NUMBER]>>},
7122
						  Parse::RecDescent::_tracefirst($text),
7123
						  q{bodysize},
7124
						  $tracelevel)
7125
							if defined $::RD_TRACE;
7126
			$expectation->failed();
7127
			last;
7128
		}
7129
		Parse::RecDescent::_trace(q{>>Matched subrule: [NUMBER]<< (return value: [}
7130
					. $_tok . q{]},
7131
 
7132
					  Parse::RecDescent::_tracefirst($text),
7133
					  q{bodysize},
7134
					  $tracelevel)
7135
						if defined $::RD_TRACE;
7136
		$item{q{NUMBER}} = $_tok;
7137
		push @item, $_tok;
7138
 
7139
		}
7140
 
7141
		Parse::RecDescent::_trace(q{Trying action},
7142
					  Parse::RecDescent::_tracefirst($text),
7143
					  q{bodysize},
7144
					  $tracelevel)
7145
						if defined $::RD_TRACE;
7146
 
7147
 
7148
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{NUMBER} ;$return||defined($return);};
7149
		unless (defined $_tok)
7150
		{
7151
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
7152
					if defined $::RD_TRACE;
7153
			last;
7154
		}
7155
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
7156
					  . $_tok . q{])},
7157
					  Parse::RecDescent::_tracefirst($text))
7158
						if defined $::RD_TRACE;
7159
		push @item, $_tok;
7160
		$item{__ACTION1__}=$_tok;
7161
 
7162
 
7163
 
7164
		Parse::RecDescent::_trace(q{>>Matched production: [NUMBER]<<},
7165
					  Parse::RecDescent::_tracefirst($text),
7166
					  q{bodysize},
7167
					  $tracelevel)
7168
						if defined $::RD_TRACE;
7169
		$_matched = 1;
7170
		last;
7171
	}
7172
 
7173
		splice
7174
				@{$thisparser->{deferred}}, $def_at unless $_matched;
7175
 
7176
        unless ( $_matched || defined($score) )
7177
	{
7178
				splice @{$thisparser->{deferred}}, $def_at;
7179
 
7180
 
7181
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
7182
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
7183
					 Parse::RecDescent::_tracefirst($_[1]),
7184
					 q{bodysize},
7185
					 $tracelevel)
7186
					if defined $::RD_TRACE;
7187
		return undef;
7188
	}
7189
	if (!defined($return) && defined($score))
7190
	{
7191
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
7192
					  q{bodysize},
7193
					  $tracelevel)
7194
						if defined $::RD_TRACE;
7195
		$return = $score_return;
7196
	}
7197
	splice @{$thisparser->{errors}}, $err_at;
7198
	$return = $item[$#item] unless defined $return;
7199
	if (defined $::RD_TRACE)
7200
	{
7201
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
7202
					  $return . q{])}, "",
7203
					  q{bodysize},
7204
					  $tracelevel);
7205
		Parse::RecDescent::_trace(q{(consumed: [} .
7206
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
7207
					  Parse::RecDescent::_tracefirst($text),
7208
					  , q{bodysize},
7209
					  $tracelevel)
7210
	}
7211
	$_[1] = $text;
7212
	return $return;
7213
}
7214
 
7215
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
7216
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING
7217
{
7218
	my $thisparser = $_[0];
7219
	use vars q{$tracelevel};
7220
	local $tracelevel = ($tracelevel||0)+1;
7221
	$ERRORS = 0;
7222
	my $thisrule = $thisparser->{"rules"}{"STRING"};
7223
 
7224
	Parse::RecDescent::_trace(q{Trying rule: [STRING]},
7225
				  Parse::RecDescent::_tracefirst($_[1]),
7226
				  q{STRING},
7227
				  $tracelevel)
7228
					if defined $::RD_TRACE;
7229
 
7230
	my $def_at = @{$thisparser->{deferred}};
7231
	my $err_at = @{$thisparser->{errors}};
7232
 
7233
	my $score;
7234
	my $score_return;
7235
	my $_tok;
7236
	my $return = undef;
7237
	my $_matched=0;
7238
	my $commit=0;
7239
	my @item = ();
7240
	my %item = ();
7241
	my $repeating =  defined($_[2]) && $_[2];
7242
	my $_noactions = defined($_[3]) && $_[3];
7243
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
7244
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
7245
	my $text;
7246
	my $lastsep="";
7247
    my $expectation = new Parse::RecDescent::Expectation(q{QUOTED_STRING, or BARESTRING});
7248
	$expectation->at($_[1]);
7249
 
7250
	my $thisline;
7251
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
7252
 
7253
 
7254
 
7255
	while (!$_matched && !$commit)
7256
	{
7257
 
7258
		Parse::RecDescent::_trace(q{Trying production: [QUOTED_STRING]},
7259
					  Parse::RecDescent::_tracefirst($_[1]),
7260
					  q{STRING},
7261
					  $tracelevel)
7262
						if defined $::RD_TRACE;
7263
		my $thisprod = $thisrule->{"prods"}[0];
7264
		$text = $_[1];
7265
		my $_savetext;
7266
		@item = (q{STRING});
7267
		%item = (__RULE__ => q{STRING});
7268
		my $repcount = 0;
7269
 
7270
 
7271
		Parse::RecDescent::_trace(q{Trying subrule: [QUOTED_STRING]},
7272
				  Parse::RecDescent::_tracefirst($text),
7273
				  q{STRING},
7274
				  $tracelevel)
7275
					if defined $::RD_TRACE;
7276
		if (1) { no strict qw{refs};
7277
		$expectation->is(q{})->at($text);
7278
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::QUOTED_STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
7279
		{
7280
 
7281
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [QUOTED_STRING]>>},
7282
						  Parse::RecDescent::_tracefirst($text),
7283
						  q{STRING},
7284
						  $tracelevel)
7285
							if defined $::RD_TRACE;
7286
			$expectation->failed();
7287
			last;
7288
		}
7289
		Parse::RecDescent::_trace(q{>>Matched subrule: [QUOTED_STRING]<< (return value: [}
7290
					. $_tok . q{]},
7291
 
7292
					  Parse::RecDescent::_tracefirst($text),
7293
					  q{STRING},
7294
					  $tracelevel)
7295
						if defined $::RD_TRACE;
7296
		$item{q{QUOTED_STRING}} = $_tok;
7297
		push @item, $_tok;
7298
 
7299
		}
7300
 
7301
 
7302
		Parse::RecDescent::_trace(q{>>Matched production: [QUOTED_STRING]<<},
7303
					  Parse::RecDescent::_tracefirst($text),
7304
					  q{STRING},
7305
					  $tracelevel)
7306
						if defined $::RD_TRACE;
7307
		$_matched = 1;
7308
		last;
7309
	}
7310
 
7311
		splice
7312
				@{$thisparser->{deferred}}, $def_at unless $_matched;
7313
 
7314
	while (!$_matched && !$commit)
7315
	{
7316
 
7317
		Parse::RecDescent::_trace(q{Trying production: [BARESTRING]},
7318
					  Parse::RecDescent::_tracefirst($_[1]),
7319
					  q{STRING},
7320
					  $tracelevel)
7321
						if defined $::RD_TRACE;
7322
		my $thisprod = $thisrule->{"prods"}[1];
7323
		$text = $_[1];
7324
		my $_savetext;
7325
		@item = (q{STRING});
7326
		%item = (__RULE__ => q{STRING});
7327
		my $repcount = 0;
7328
 
7329
 
7330
		Parse::RecDescent::_trace(q{Trying subrule: [BARESTRING]},
7331
				  Parse::RecDescent::_tracefirst($text),
7332
				  q{STRING},
7333
				  $tracelevel)
7334
					if defined $::RD_TRACE;
7335
		if (1) { no strict qw{refs};
7336
		$expectation->is(q{})->at($text);
7337
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::BARESTRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
7338
		{
7339
 
7340
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [BARESTRING]>>},
7341
						  Parse::RecDescent::_tracefirst($text),
7342
						  q{STRING},
7343
						  $tracelevel)
7344
							if defined $::RD_TRACE;
7345
			$expectation->failed();
7346
			last;
7347
		}
7348
		Parse::RecDescent::_trace(q{>>Matched subrule: [BARESTRING]<< (return value: [}
7349
					. $_tok . q{]},
7350
 
7351
					  Parse::RecDescent::_tracefirst($text),
7352
					  q{STRING},
7353
					  $tracelevel)
7354
						if defined $::RD_TRACE;
7355
		$item{q{BARESTRING}} = $_tok;
7356
		push @item, $_tok;
7357
 
7358
		}
7359
 
7360
		Parse::RecDescent::_trace(q{Trying action},
7361
					  Parse::RecDescent::_tracefirst($text),
7362
					  q{STRING},
7363
					  $tracelevel)
7364
						if defined $::RD_TRACE;
7365
 
7366
 
7367
		$_tok = ($_noactions) ? 0 : do {
7368
	 $return = $item{QUOTED_STRING}||$item{BARESTRING} ;
7369
	 $return||defined($return);
7370
};
7371
		unless (defined $_tok)
7372
		{
7373
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
7374
					if defined $::RD_TRACE;
7375
			last;
7376
		}
7377
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
7378
					  . $_tok . q{])},
7379
					  Parse::RecDescent::_tracefirst($text))
7380
						if defined $::RD_TRACE;
7381
		push @item, $_tok;
7382
		$item{__ACTION1__}=$_tok;
7383
 
7384
 
7385
 
7386
		Parse::RecDescent::_trace(q{>>Matched production: [BARESTRING]<<},
7387
					  Parse::RecDescent::_tracefirst($text),
7388
					  q{STRING},
7389
					  $tracelevel)
7390
						if defined $::RD_TRACE;
7391
		$_matched = 1;
7392
		last;
7393
	}
7394
 
7395
		splice
7396
				@{$thisparser->{deferred}}, $def_at unless $_matched;
7397
 
7398
        unless ( $_matched || defined($score) )
7399
	{
7400
				splice @{$thisparser->{deferred}}, $def_at;
7401
 
7402
 
7403
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
7404
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
7405
					 Parse::RecDescent::_tracefirst($_[1]),
7406
					 q{STRING},
7407
					 $tracelevel)
7408
					if defined $::RD_TRACE;
7409
		return undef;
7410
	}
7411
	if (!defined($return) && defined($score))
7412
	{
7413
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
7414
					  q{STRING},
7415
					  $tracelevel)
7416
						if defined $::RD_TRACE;
7417
		$return = $score_return;
7418
	}
7419
	splice @{$thisparser->{errors}}, $err_at;
7420
	$return = $item[$#item] unless defined $return;
7421
	if (defined $::RD_TRACE)
7422
	{
7423
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
7424
					  $return . q{])}, "",
7425
					  q{STRING},
7426
					  $tracelevel);
7427
		Parse::RecDescent::_trace(q{(consumed: [} .
7428
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
7429
					  Parse::RecDescent::_tracefirst($text),
7430
					  , q{STRING},
7431
					  $tracelevel)
7432
	}
7433
	$_[1] = $text;
7434
	return $return;
7435
}
7436
 
7437
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
7438
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodytype
7439
{
7440
	my $thisparser = $_[0];
7441
	use vars q{$tracelevel};
7442
	local $tracelevel = ($tracelevel||0)+1;
7443
	$ERRORS = 0;
7444
	my $thisrule = $thisparser->{"rules"}{"bodytype"};
7445
 
7446
	Parse::RecDescent::_trace(q{Trying rule: [bodytype]},
7447
				  Parse::RecDescent::_tracefirst($_[1]),
7448
				  q{bodytype},
7449
				  $tracelevel)
7450
					if defined $::RD_TRACE;
7451
 
7452
	my $def_at = @{$thisparser->{deferred}};
7453
	my $err_at = @{$thisparser->{errors}};
7454
 
7455
	my $score;
7456
	my $score_return;
7457
	my $_tok;
7458
	my $return = undef;
7459
	my $_matched=0;
7460
	my $commit=0;
7461
	my @item = ();
7462
	my %item = ();
7463
	my $repeating =  defined($_[2]) && $_[2];
7464
	my $_noactions = defined($_[3]) && $_[3];
7465
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
7466
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
7467
	my $text;
7468
	my $lastsep="";
7469
    my $expectation = new Parse::RecDescent::Expectation(q{STRING});
7470
	$expectation->at($_[1]);
7471
 
7472
	my $thisline;
7473
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
7474
 
7475
 
7476
 
7477
	while (!$_matched && !$commit)
7478
	{
7479
 
7480
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
7481
					  Parse::RecDescent::_tracefirst($_[1]),
7482
					  q{bodytype},
7483
					  $tracelevel)
7484
						if defined $::RD_TRACE;
7485
		my $thisprod = $thisrule->{"prods"}[0];
7486
		$text = $_[1];
7487
		my $_savetext;
7488
		@item = (q{bodytype});
7489
		%item = (__RULE__ => q{bodytype});
7490
		my $repcount = 0;
7491
 
7492
 
7493
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
7494
				  Parse::RecDescent::_tracefirst($text),
7495
				  q{bodytype},
7496
				  $tracelevel)
7497
					if defined $::RD_TRACE;
7498
		if (1) { no strict qw{refs};
7499
		$expectation->is(q{})->at($text);
7500
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
7501
		{
7502
 
7503
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
7504
						  Parse::RecDescent::_tracefirst($text),
7505
						  q{bodytype},
7506
						  $tracelevel)
7507
							if defined $::RD_TRACE;
7508
			$expectation->failed();
7509
			last;
7510
		}
7511
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
7512
					. $_tok . q{]},
7513
 
7514
					  Parse::RecDescent::_tracefirst($text),
7515
					  q{bodytype},
7516
					  $tracelevel)
7517
						if defined $::RD_TRACE;
7518
		$item{q{STRING}} = $_tok;
7519
		push @item, $_tok;
7520
 
7521
		}
7522
 
7523
		Parse::RecDescent::_trace(q{Trying action},
7524
					  Parse::RecDescent::_tracefirst($text),
7525
					  q{bodytype},
7526
					  $tracelevel)
7527
						if defined $::RD_TRACE;
7528
 
7529
 
7530
		$_tok = ($_noactions) ? 0 : do { $return = $item{STRING} ; $return||defined($return);};
7531
		unless (defined $_tok)
7532
		{
7533
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
7534
					if defined $::RD_TRACE;
7535
			last;
7536
		}
7537
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
7538
					  . $_tok . q{])},
7539
					  Parse::RecDescent::_tracefirst($text))
7540
						if defined $::RD_TRACE;
7541
		push @item, $_tok;
7542
		$item{__ACTION1__}=$_tok;
7543
 
7544
 
7545
 
7546
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
7547
					  Parse::RecDescent::_tracefirst($text),
7548
					  q{bodytype},
7549
					  $tracelevel)
7550
						if defined $::RD_TRACE;
7551
		$_matched = 1;
7552
		last;
7553
	}
7554
 
7555
		splice
7556
				@{$thisparser->{deferred}}, $def_at unless $_matched;
7557
 
7558
        unless ( $_matched || defined($score) )
7559
	{
7560
				splice @{$thisparser->{deferred}}, $def_at;
7561
 
7562
 
7563
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
7564
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
7565
					 Parse::RecDescent::_tracefirst($_[1]),
7566
					 q{bodytype},
7567
					 $tracelevel)
7568
					if defined $::RD_TRACE;
7569
		return undef;
7570
	}
7571
	if (!defined($return) && defined($score))
7572
	{
7573
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
7574
					  q{bodytype},
7575
					  $tracelevel)
7576
						if defined $::RD_TRACE;
7577
		$return = $score_return;
7578
	}
7579
	splice @{$thisparser->{errors}}, $err_at;
7580
	$return = $item[$#item] unless defined $return;
7581
	if (defined $::RD_TRACE)
7582
	{
7583
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
7584
					  $return . q{])}, "",
7585
					  q{bodytype},
7586
					  $tracelevel);
7587
		Parse::RecDescent::_trace(q{(consumed: [} .
7588
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
7589
					  Parse::RecDescent::_tracefirst($text),
7590
					  , q{bodytype},
7591
					  $tracelevel)
7592
	}
7593
	$_[1] = $text;
7594
	return $return;
7595
}
7596
 
7597
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
7598
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::TEXT
7599
{
7600
	my $thisparser = $_[0];
7601
	use vars q{$tracelevel};
7602
	local $tracelevel = ($tracelevel||0)+1;
7603
	$ERRORS = 0;
7604
	my $thisrule = $thisparser->{"rules"}{"TEXT"};
7605
 
7606
	Parse::RecDescent::_trace(q{Trying rule: [TEXT]},
7607
				  Parse::RecDescent::_tracefirst($_[1]),
7608
				  q{TEXT},
7609
				  $tracelevel)
7610
					if defined $::RD_TRACE;
7611
 
7612
	my $def_at = @{$thisparser->{deferred}};
7613
	my $err_at = @{$thisparser->{errors}};
7614
 
7615
	my $score;
7616
	my $score_return;
7617
	my $_tok;
7618
	my $return = undef;
7619
	my $_matched=0;
7620
	my $commit=0;
7621
	my @item = ();
7622
	my %item = ();
7623
	my $repeating =  defined($_[2]) && $_[2];
7624
	my $_noactions = defined($_[3]) && $_[3];
7625
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
7626
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
7627
	my $text;
7628
	my $lastsep="";
7629
    my $expectation = new Parse::RecDescent::Expectation(q{/^"TEXT"|^TEXT/i});
7630
	$expectation->at($_[1]);
7631
 
7632
	my $thisline;
7633
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
7634
 
7635
 
7636
 
7637
	while (!$_matched && !$commit)
7638
	{
7639
 
7640
		Parse::RecDescent::_trace(q{Trying production: [/^"TEXT"|^TEXT/i]},
7641
					  Parse::RecDescent::_tracefirst($_[1]),
7642
					  q{TEXT},
7643
					  $tracelevel)
7644
						if defined $::RD_TRACE;
7645
		my $thisprod = $thisrule->{"prods"}[0];
7646
		$text = $_[1];
7647
		my $_savetext;
7648
		@item = (q{TEXT});
7649
		%item = (__RULE__ => q{TEXT});
7650
		my $repcount = 0;
7651
 
7652
 
7653
		Parse::RecDescent::_trace(q{Trying terminal: [/^"TEXT"|^TEXT/i]}, Parse::RecDescent::_tracefirst($text),
7654
					  q{TEXT},
7655
					  $tracelevel)
7656
						if defined $::RD_TRACE;
7657
		$lastsep = "";
7658
		$expectation->is(q{})->at($text);
7659
 
7660
 
7661
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:^"TEXT"|^TEXT)//i)
7662
		{
7663
 
7664
			$expectation->failed();
7665
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7666
						  Parse::RecDescent::_tracefirst($text))
7667
					if defined $::RD_TRACE;
7668
 
7669
			last;
7670
		}
7671
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7672
						. $& . q{])},
7673
						  Parse::RecDescent::_tracefirst($text))
7674
					if defined $::RD_TRACE;
7675
		push @item, $item{__PATTERN1__}=$&;
7676
 
7677
 
7678
		Parse::RecDescent::_trace(q{Trying action},
7679
					  Parse::RecDescent::_tracefirst($text),
7680
					  q{TEXT},
7681
					  $tracelevel)
7682
						if defined $::RD_TRACE;
7683
 
7684
 
7685
		$_tok = ($_noactions) ? 0 : do { $return = "TEXT" };
7686
		unless (defined $_tok)
7687
		{
7688
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
7689
					if defined $::RD_TRACE;
7690
			last;
7691
		}
7692
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
7693
					  . $_tok . q{])},
7694
					  Parse::RecDescent::_tracefirst($text))
7695
						if defined $::RD_TRACE;
7696
		push @item, $_tok;
7697
		$item{__ACTION1__}=$_tok;
7698
 
7699
 
7700
 
7701
		Parse::RecDescent::_trace(q{>>Matched production: [/^"TEXT"|^TEXT/i]<<},
7702
					  Parse::RecDescent::_tracefirst($text),
7703
					  q{TEXT},
7704
					  $tracelevel)
7705
						if defined $::RD_TRACE;
7706
		$_matched = 1;
7707
		last;
7708
	}
7709
 
7710
		splice
7711
				@{$thisparser->{deferred}}, $def_at unless $_matched;
7712
 
7713
        unless ( $_matched || defined($score) )
7714
	{
7715
				splice @{$thisparser->{deferred}}, $def_at;
7716
 
7717
 
7718
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
7719
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
7720
					 Parse::RecDescent::_tracefirst($_[1]),
7721
					 q{TEXT},
7722
					 $tracelevel)
7723
					if defined $::RD_TRACE;
7724
		return undef;
7725
	}
7726
	if (!defined($return) && defined($score))
7727
	{
7728
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
7729
					  q{TEXT},
7730
					  $tracelevel)
7731
						if defined $::RD_TRACE;
7732
		$return = $score_return;
7733
	}
7734
	splice @{$thisparser->{errors}}, $err_at;
7735
	$return = $item[$#item] unless defined $return;
7736
	if (defined $::RD_TRACE)
7737
	{
7738
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
7739
					  $return . q{])}, "",
7740
					  q{TEXT},
7741
					  $tracelevel);
7742
		Parse::RecDescent::_trace(q{(consumed: [} .
7743
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
7744
					  Parse::RecDescent::_tracefirst($text),
7745
					  , q{TEXT},
7746
					  $tracelevel)
7747
	}
7748
	$_[1] = $text;
7749
	return $return;
7750
}
7751
 
7752
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
7753
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::to
7754
{
7755
	my $thisparser = $_[0];
7756
	use vars q{$tracelevel};
7757
	local $tracelevel = ($tracelevel||0)+1;
7758
	$ERRORS = 0;
7759
	my $thisrule = $thisparser->{"rules"}{"to"};
7760
 
7761
	Parse::RecDescent::_trace(q{Trying rule: [to]},
7762
				  Parse::RecDescent::_tracefirst($_[1]),
7763
				  q{to},
7764
				  $tracelevel)
7765
					if defined $::RD_TRACE;
7766
 
7767
	my $def_at = @{$thisparser->{deferred}};
7768
	my $err_at = @{$thisparser->{errors}};
7769
 
7770
	my $score;
7771
	my $score_return;
7772
	my $_tok;
7773
	my $return = undef;
7774
	my $_matched=0;
7775
	my $commit=0;
7776
	my @item = ();
7777
	my %item = ();
7778
	my $repeating =  defined($_[2]) && $_[2];
7779
	my $_noactions = defined($_[3]) && $_[3];
7780
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
7781
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
7782
	my $text;
7783
	my $lastsep="";
7784
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or '('});
7785
	$expectation->at($_[1]);
7786
 
7787
	my $thisline;
7788
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
7789
 
7790
 
7791
 
7792
	while (!$_matched && !$commit)
7793
	{
7794
 
7795
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
7796
					  Parse::RecDescent::_tracefirst($_[1]),
7797
					  q{to},
7798
					  $tracelevel)
7799
						if defined $::RD_TRACE;
7800
		my $thisprod = $thisrule->{"prods"}[0];
7801
		$text = $_[1];
7802
		my $_savetext;
7803
		@item = (q{to});
7804
		%item = (__RULE__ => q{to});
7805
		my $repcount = 0;
7806
 
7807
 
7808
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
7809
				  Parse::RecDescent::_tracefirst($text),
7810
				  q{to},
7811
				  $tracelevel)
7812
					if defined $::RD_TRACE;
7813
		if (1) { no strict qw{refs};
7814
		$expectation->is(q{})->at($text);
7815
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
7816
		{
7817
 
7818
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
7819
						  Parse::RecDescent::_tracefirst($text),
7820
						  q{to},
7821
						  $tracelevel)
7822
							if defined $::RD_TRACE;
7823
			$expectation->failed();
7824
			last;
7825
		}
7826
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
7827
					. $_tok . q{]},
7828
 
7829
					  Parse::RecDescent::_tracefirst($text),
7830
					  q{to},
7831
					  $tracelevel)
7832
						if defined $::RD_TRACE;
7833
		$item{q{NIL}} = $_tok;
7834
		push @item, $_tok;
7835
 
7836
		}
7837
 
7838
 
7839
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
7840
					  Parse::RecDescent::_tracefirst($text),
7841
					  q{to},
7842
					  $tracelevel)
7843
						if defined $::RD_TRACE;
7844
		$_matched = 1;
7845
		last;
7846
	}
7847
 
7848
		splice
7849
				@{$thisparser->{deferred}}, $def_at unless $_matched;
7850
 
7851
	while (!$_matched && !$commit)
7852
	{
7853
 
7854
		Parse::RecDescent::_trace(q{Trying production: ['(' addressstruct ')']},
7855
					  Parse::RecDescent::_tracefirst($_[1]),
7856
					  q{to},
7857
					  $tracelevel)
7858
						if defined $::RD_TRACE;
7859
		my $thisprod = $thisrule->{"prods"}[1];
7860
		$text = $_[1];
7861
		my $_savetext;
7862
		@item = (q{to});
7863
		%item = (__RULE__ => q{to});
7864
		my $repcount = 0;
7865
 
7866
 
7867
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
7868
					  Parse::RecDescent::_tracefirst($text),
7869
					  q{to},
7870
					  $tracelevel)
7871
						if defined $::RD_TRACE;
7872
		$lastsep = "";
7873
		$expectation->is(q{})->at($text);
7874
 
7875
 
7876
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "("; 1 } and
7877
		     substr($text,0,length($_tok)) eq $_tok and
7878
		     do { substr($text,0,length($_tok)) = ""; 1; }
7879
		)
7880
		{
7881
 
7882
			$expectation->failed();
7883
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7884
						  Parse::RecDescent::_tracefirst($text))
7885
							if defined $::RD_TRACE;
7886
			last;
7887
		}
7888
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7889
						. $_tok . q{])},
7890
						  Parse::RecDescent::_tracefirst($text))
7891
							if defined $::RD_TRACE;
7892
		push @item, $item{__STRING1__}=$_tok;
7893
 
7894
 
7895
		Parse::RecDescent::_trace(q{Trying repeated subrule: [addressstruct]},
7896
				  Parse::RecDescent::_tracefirst($text),
7897
				  q{to},
7898
				  $tracelevel)
7899
					if defined $::RD_TRACE;
7900
		$expectation->is(q{addressstruct})->at($text);
7901
 
7902
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::addressstruct, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
7903
		{
7904
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [addressstruct]>>},
7905
						  Parse::RecDescent::_tracefirst($text),
7906
						  q{to},
7907
						  $tracelevel)
7908
							if defined $::RD_TRACE;
7909
			last;
7910
		}
7911
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [addressstruct]<< (}
7912
					. @$_tok . q{ times)},
7913
 
7914
					  Parse::RecDescent::_tracefirst($text),
7915
					  q{to},
7916
					  $tracelevel)
7917
						if defined $::RD_TRACE;
7918
		$item{q{addressstruct(s)}} = $_tok;
7919
		push @item, $_tok;
7920
 
7921
 
7922
 
7923
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
7924
					  Parse::RecDescent::_tracefirst($text),
7925
					  q{to},
7926
					  $tracelevel)
7927
						if defined $::RD_TRACE;
7928
		$lastsep = "";
7929
		$expectation->is(q{')'})->at($text);
7930
 
7931
 
7932
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
7933
		     substr($text,0,length($_tok)) eq $_tok and
7934
		     do { substr($text,0,length($_tok)) = ""; 1; }
7935
		)
7936
		{
7937
 
7938
			$expectation->failed();
7939
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7940
						  Parse::RecDescent::_tracefirst($text))
7941
							if defined $::RD_TRACE;
7942
			last;
7943
		}
7944
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7945
						. $_tok . q{])},
7946
						  Parse::RecDescent::_tracefirst($text))
7947
							if defined $::RD_TRACE;
7948
		push @item, $item{__STRING2__}=$_tok;
7949
 
7950
 
7951
		Parse::RecDescent::_trace(q{Trying action},
7952
					  Parse::RecDescent::_tracefirst($text),
7953
					  q{to},
7954
					  $tracelevel)
7955
						if defined $::RD_TRACE;
7956
 
7957
 
7958
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{'addressstruct(s)'} };
7959
		unless (defined $_tok)
7960
		{
7961
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
7962
					if defined $::RD_TRACE;
7963
			last;
7964
		}
7965
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
7966
					  . $_tok . q{])},
7967
					  Parse::RecDescent::_tracefirst($text))
7968
						if defined $::RD_TRACE;
7969
		push @item, $_tok;
7970
		$item{__ACTION1__}=$_tok;
7971
 
7972
 
7973
 
7974
		Parse::RecDescent::_trace(q{>>Matched production: ['(' addressstruct ')']<<},
7975
					  Parse::RecDescent::_tracefirst($text),
7976
					  q{to},
7977
					  $tracelevel)
7978
						if defined $::RD_TRACE;
7979
		$_matched = 1;
7980
		last;
7981
	}
7982
 
7983
		splice
7984
				@{$thisparser->{deferred}}, $def_at unless $_matched;
7985
 
7986
        unless ( $_matched || defined($score) )
7987
	{
7988
				splice @{$thisparser->{deferred}}, $def_at;
7989
 
7990
 
7991
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
7992
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
7993
					 Parse::RecDescent::_tracefirst($_[1]),
7994
					 q{to},
7995
					 $tracelevel)
7996
					if defined $::RD_TRACE;
7997
		return undef;
7998
	}
7999
	if (!defined($return) && defined($score))
8000
	{
8001
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
8002
					  q{to},
8003
					  $tracelevel)
8004
						if defined $::RD_TRACE;
8005
		$return = $score_return;
8006
	}
8007
	splice @{$thisparser->{errors}}, $err_at;
8008
	$return = $item[$#item] unless defined $return;
8009
	if (defined $::RD_TRACE)
8010
	{
8011
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
8012
					  $return . q{])}, "",
8013
					  q{to},
8014
					  $tracelevel);
8015
		Parse::RecDescent::_trace(q{(consumed: [} .
8016
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
8017
					  Parse::RecDescent::_tracefirst($text),
8018
					  , q{to},
8019
					  $tracelevel)
8020
	}
8021
	$_[1] = $text;
8022
	return $return;
8023
}
8024
 
8025
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
8026
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL
8027
{
8028
	my $thisparser = $_[0];
8029
	use vars q{$tracelevel};
8030
	local $tracelevel = ($tracelevel||0)+1;
8031
	$ERRORS = 0;
8032
	my $thisrule = $thisparser->{"rules"}{"NIL"};
8033
 
8034
	Parse::RecDescent::_trace(q{Trying rule: [NIL]},
8035
				  Parse::RecDescent::_tracefirst($_[1]),
8036
				  q{NIL},
8037
				  $tracelevel)
8038
					if defined $::RD_TRACE;
8039
 
8040
	my $def_at = @{$thisparser->{deferred}};
8041
	my $err_at = @{$thisparser->{errors}};
8042
 
8043
	my $score;
8044
	my $score_return;
8045
	my $_tok;
8046
	my $return = undef;
8047
	my $_matched=0;
8048
	my $commit=0;
8049
	my @item = ();
8050
	my %item = ();
8051
	my $repeating =  defined($_[2]) && $_[2];
8052
	my $_noactions = defined($_[3]) && $_[3];
8053
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
8054
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
8055
	my $text;
8056
	my $lastsep="";
8057
    my $expectation = new Parse::RecDescent::Expectation(q{/^NIL/i});
8058
	$expectation->at($_[1]);
8059
 
8060
	my $thisline;
8061
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
8062
 
8063
 
8064
 
8065
	while (!$_matched && !$commit)
8066
	{
8067
 
8068
		Parse::RecDescent::_trace(q{Trying production: [/^NIL/i]},
8069
					  Parse::RecDescent::_tracefirst($_[1]),
8070
					  q{NIL},
8071
					  $tracelevel)
8072
						if defined $::RD_TRACE;
8073
		my $thisprod = $thisrule->{"prods"}[0];
8074
		$text = $_[1];
8075
		my $_savetext;
8076
		@item = (q{NIL});
8077
		%item = (__RULE__ => q{NIL});
8078
		my $repcount = 0;
8079
 
8080
 
8081
		Parse::RecDescent::_trace(q{Trying terminal: [/^NIL/i]}, Parse::RecDescent::_tracefirst($text),
8082
					  q{NIL},
8083
					  $tracelevel)
8084
						if defined $::RD_TRACE;
8085
		$lastsep = "";
8086
		$expectation->is(q{})->at($text);
8087
 
8088
 
8089
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:^NIL)//i)
8090
		{
8091
 
8092
			$expectation->failed();
8093
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
8094
						  Parse::RecDescent::_tracefirst($text))
8095
					if defined $::RD_TRACE;
8096
 
8097
			last;
8098
		}
8099
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
8100
						. $& . q{])},
8101
						  Parse::RecDescent::_tracefirst($text))
8102
					if defined $::RD_TRACE;
8103
		push @item, $item{__PATTERN1__}=$&;
8104
 
8105
 
8106
		Parse::RecDescent::_trace(q{Trying action},
8107
					  Parse::RecDescent::_tracefirst($text),
8108
					  q{NIL},
8109
					  $tracelevel)
8110
						if defined $::RD_TRACE;
8111
 
8112
 
8113
		$_tok = ($_noactions) ? 0 : do { $return = "NIL" 	};
8114
		unless (defined $_tok)
8115
		{
8116
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
8117
					if defined $::RD_TRACE;
8118
			last;
8119
		}
8120
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
8121
					  . $_tok . q{])},
8122
					  Parse::RecDescent::_tracefirst($text))
8123
						if defined $::RD_TRACE;
8124
		push @item, $_tok;
8125
		$item{__ACTION1__}=$_tok;
8126
 
8127
 
8128
 
8129
		Parse::RecDescent::_trace(q{>>Matched production: [/^NIL/i]<<},
8130
					  Parse::RecDescent::_tracefirst($text),
8131
					  q{NIL},
8132
					  $tracelevel)
8133
						if defined $::RD_TRACE;
8134
		$_matched = 1;
8135
		last;
8136
	}
8137
 
8138
		splice
8139
				@{$thisparser->{deferred}}, $def_at unless $_matched;
8140
 
8141
        unless ( $_matched || defined($score) )
8142
	{
8143
				splice @{$thisparser->{deferred}}, $def_at;
8144
 
8145
 
8146
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
8147
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
8148
					 Parse::RecDescent::_tracefirst($_[1]),
8149
					 q{NIL},
8150
					 $tracelevel)
8151
					if defined $::RD_TRACE;
8152
		return undef;
8153
	}
8154
	if (!defined($return) && defined($score))
8155
	{
8156
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
8157
					  q{NIL},
8158
					  $tracelevel)
8159
						if defined $::RD_TRACE;
8160
		$return = $score_return;
8161
	}
8162
	splice @{$thisparser->{errors}}, $err_at;
8163
	$return = $item[$#item] unless defined $return;
8164
	if (defined $::RD_TRACE)
8165
	{
8166
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
8167
					  $return . q{])}, "",
8168
					  q{NIL},
8169
					  $tracelevel);
8170
		Parse::RecDescent::_trace(q{(consumed: [} .
8171
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
8172
					  Parse::RecDescent::_tracefirst($text),
8173
					  , q{NIL},
8174
					  $tracelevel)
8175
	}
8176
	$_[1] = $text;
8177
	return $return;
8178
}
8179
 
8180
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
8181
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::from
8182
{
8183
	my $thisparser = $_[0];
8184
	use vars q{$tracelevel};
8185
	local $tracelevel = ($tracelevel||0)+1;
8186
	$ERRORS = 0;
8187
	my $thisrule = $thisparser->{"rules"}{"from"};
8188
 
8189
	Parse::RecDescent::_trace(q{Trying rule: [from]},
8190
				  Parse::RecDescent::_tracefirst($_[1]),
8191
				  q{from},
8192
				  $tracelevel)
8193
					if defined $::RD_TRACE;
8194
 
8195
	my $def_at = @{$thisparser->{deferred}};
8196
	my $err_at = @{$thisparser->{errors}};
8197
 
8198
	my $score;
8199
	my $score_return;
8200
	my $_tok;
8201
	my $return = undef;
8202
	my $_matched=0;
8203
	my $commit=0;
8204
	my @item = ();
8205
	my %item = ();
8206
	my $repeating =  defined($_[2]) && $_[2];
8207
	my $_noactions = defined($_[3]) && $_[3];
8208
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
8209
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
8210
	my $text;
8211
	my $lastsep="";
8212
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or '('});
8213
	$expectation->at($_[1]);
8214
 
8215
	my $thisline;
8216
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
8217
 
8218
 
8219
 
8220
	while (!$_matched && !$commit)
8221
	{
8222
 
8223
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
8224
					  Parse::RecDescent::_tracefirst($_[1]),
8225
					  q{from},
8226
					  $tracelevel)
8227
						if defined $::RD_TRACE;
8228
		my $thisprod = $thisrule->{"prods"}[0];
8229
		$text = $_[1];
8230
		my $_savetext;
8231
		@item = (q{from});
8232
		%item = (__RULE__ => q{from});
8233
		my $repcount = 0;
8234
 
8235
 
8236
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
8237
				  Parse::RecDescent::_tracefirst($text),
8238
				  q{from},
8239
				  $tracelevel)
8240
					if defined $::RD_TRACE;
8241
		if (1) { no strict qw{refs};
8242
		$expectation->is(q{})->at($text);
8243
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
8244
		{
8245
 
8246
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
8247
						  Parse::RecDescent::_tracefirst($text),
8248
						  q{from},
8249
						  $tracelevel)
8250
							if defined $::RD_TRACE;
8251
			$expectation->failed();
8252
			last;
8253
		}
8254
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
8255
					. $_tok . q{]},
8256
 
8257
					  Parse::RecDescent::_tracefirst($text),
8258
					  q{from},
8259
					  $tracelevel)
8260
						if defined $::RD_TRACE;
8261
		$item{q{NIL}} = $_tok;
8262
		push @item, $_tok;
8263
 
8264
		}
8265
 
8266
 
8267
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
8268
					  Parse::RecDescent::_tracefirst($text),
8269
					  q{from},
8270
					  $tracelevel)
8271
						if defined $::RD_TRACE;
8272
		$_matched = 1;
8273
		last;
8274
	}
8275
 
8276
		splice
8277
				@{$thisparser->{deferred}}, $def_at unless $_matched;
8278
 
8279
	while (!$_matched && !$commit)
8280
	{
8281
 
8282
		Parse::RecDescent::_trace(q{Trying production: ['(' addressstruct ')']},
8283
					  Parse::RecDescent::_tracefirst($_[1]),
8284
					  q{from},
8285
					  $tracelevel)
8286
						if defined $::RD_TRACE;
8287
		my $thisprod = $thisrule->{"prods"}[1];
8288
		$text = $_[1];
8289
		my $_savetext;
8290
		@item = (q{from});
8291
		%item = (__RULE__ => q{from});
8292
		my $repcount = 0;
8293
 
8294
 
8295
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
8296
					  Parse::RecDescent::_tracefirst($text),
8297
					  q{from},
8298
					  $tracelevel)
8299
						if defined $::RD_TRACE;
8300
		$lastsep = "";
8301
		$expectation->is(q{})->at($text);
8302
 
8303
 
8304
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "("; 1 } and
8305
		     substr($text,0,length($_tok)) eq $_tok and
8306
		     do { substr($text,0,length($_tok)) = ""; 1; }
8307
		)
8308
		{
8309
 
8310
			$expectation->failed();
8311
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
8312
						  Parse::RecDescent::_tracefirst($text))
8313
							if defined $::RD_TRACE;
8314
			last;
8315
		}
8316
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
8317
						. $_tok . q{])},
8318
						  Parse::RecDescent::_tracefirst($text))
8319
							if defined $::RD_TRACE;
8320
		push @item, $item{__STRING1__}=$_tok;
8321
 
8322
 
8323
		Parse::RecDescent::_trace(q{Trying repeated subrule: [addressstruct]},
8324
				  Parse::RecDescent::_tracefirst($text),
8325
				  q{from},
8326
				  $tracelevel)
8327
					if defined $::RD_TRACE;
8328
		$expectation->is(q{addressstruct})->at($text);
8329
 
8330
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::addressstruct, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
8331
		{
8332
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [addressstruct]>>},
8333
						  Parse::RecDescent::_tracefirst($text),
8334
						  q{from},
8335
						  $tracelevel)
8336
							if defined $::RD_TRACE;
8337
			last;
8338
		}
8339
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [addressstruct]<< (}
8340
					. @$_tok . q{ times)},
8341
 
8342
					  Parse::RecDescent::_tracefirst($text),
8343
					  q{from},
8344
					  $tracelevel)
8345
						if defined $::RD_TRACE;
8346
		$item{q{addressstruct(s)}} = $_tok;
8347
		push @item, $_tok;
8348
 
8349
 
8350
 
8351
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
8352
					  Parse::RecDescent::_tracefirst($text),
8353
					  q{from},
8354
					  $tracelevel)
8355
						if defined $::RD_TRACE;
8356
		$lastsep = "";
8357
		$expectation->is(q{')'})->at($text);
8358
 
8359
 
8360
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
8361
		     substr($text,0,length($_tok)) eq $_tok and
8362
		     do { substr($text,0,length($_tok)) = ""; 1; }
8363
		)
8364
		{
8365
 
8366
			$expectation->failed();
8367
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
8368
						  Parse::RecDescent::_tracefirst($text))
8369
							if defined $::RD_TRACE;
8370
			last;
8371
		}
8372
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
8373
						. $_tok . q{])},
8374
						  Parse::RecDescent::_tracefirst($text))
8375
							if defined $::RD_TRACE;
8376
		push @item, $item{__STRING2__}=$_tok;
8377
 
8378
 
8379
		Parse::RecDescent::_trace(q{Trying action},
8380
					  Parse::RecDescent::_tracefirst($text),
8381
					  q{from},
8382
					  $tracelevel)
8383
						if defined $::RD_TRACE;
8384
 
8385
 
8386
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{'addressstruct(s)'} };
8387
		unless (defined $_tok)
8388
		{
8389
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
8390
					if defined $::RD_TRACE;
8391
			last;
8392
		}
8393
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
8394
					  . $_tok . q{])},
8395
					  Parse::RecDescent::_tracefirst($text))
8396
						if defined $::RD_TRACE;
8397
		push @item, $_tok;
8398
		$item{__ACTION1__}=$_tok;
8399
 
8400
 
8401
 
8402
		Parse::RecDescent::_trace(q{>>Matched production: ['(' addressstruct ')']<<},
8403
					  Parse::RecDescent::_tracefirst($text),
8404
					  q{from},
8405
					  $tracelevel)
8406
						if defined $::RD_TRACE;
8407
		$_matched = 1;
8408
		last;
8409
	}
8410
 
8411
		splice
8412
				@{$thisparser->{deferred}}, $def_at unless $_matched;
8413
 
8414
        unless ( $_matched || defined($score) )
8415
	{
8416
				splice @{$thisparser->{deferred}}, $def_at;
8417
 
8418
 
8419
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
8420
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
8421
					 Parse::RecDescent::_tracefirst($_[1]),
8422
					 q{from},
8423
					 $tracelevel)
8424
					if defined $::RD_TRACE;
8425
		return undef;
8426
	}
8427
	if (!defined($return) && defined($score))
8428
	{
8429
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
8430
					  q{from},
8431
					  $tracelevel)
8432
						if defined $::RD_TRACE;
8433
		$return = $score_return;
8434
	}
8435
	splice @{$thisparser->{errors}}, $err_at;
8436
	$return = $item[$#item] unless defined $return;
8437
	if (defined $::RD_TRACE)
8438
	{
8439
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
8440
					  $return . q{])}, "",
8441
					  q{from},
8442
					  $tracelevel);
8443
		Parse::RecDescent::_trace(q{(consumed: [} .
8444
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
8445
					  Parse::RecDescent::_tracefirst($text),
8446
					  , q{from},
8447
					  $tracelevel)
8448
	}
8449
	$_[1] = $text;
8450
	return $return;
8451
}
8452
 
8453
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
8454
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodystructure
8455
{
8456
	my $thisparser = $_[0];
8457
	use vars q{$tracelevel};
8458
	local $tracelevel = ($tracelevel||0)+1;
8459
	$ERRORS = 0;
8460
	my $thisrule = $thisparser->{"rules"}{"bodystructure"};
8461
 
8462
	Parse::RecDescent::_trace(q{Trying rule: [bodystructure]},
8463
				  Parse::RecDescent::_tracefirst($_[1]),
8464
				  q{bodystructure},
8465
				  $tracelevel)
8466
					if defined $::RD_TRACE;
8467
 
8468
	my $def_at = @{$thisparser->{deferred}};
8469
	my $err_at = @{$thisparser->{errors}};
8470
 
8471
	my $score;
8472
	my $score_return;
8473
	my $_tok;
8474
	my $return = undef;
8475
	my $_matched=0;
8476
	my $commit=0;
8477
	my @item = ();
8478
	my %item = ();
8479
	my $repeating =  defined($_[2]) && $_[2];
8480
	my $_noactions = defined($_[3]) && $_[3];
8481
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
8482
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
8483
	my $text;
8484
	my $lastsep="";
8485
    my $expectation = new Parse::RecDescent::Expectation(q{'('});
8486
	$expectation->at($_[1]);
8487
 
8488
	my $thisline;
8489
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
8490
 
8491
 
8492
 
8493
	while (!$_matched && !$commit)
8494
	{
8495
 
8496
		Parse::RecDescent::_trace(q{Trying production: ['(' part ')']},
8497
					  Parse::RecDescent::_tracefirst($_[1]),
8498
					  q{bodystructure},
8499
					  $tracelevel)
8500
						if defined $::RD_TRACE;
8501
		my $thisprod = $thisrule->{"prods"}[0];
8502
		$text = $_[1];
8503
		my $_savetext;
8504
		@item = (q{bodystructure});
8505
		%item = (__RULE__ => q{bodystructure});
8506
		my $repcount = 0;
8507
 
8508
 
8509
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
8510
					  Parse::RecDescent::_tracefirst($text),
8511
					  q{bodystructure},
8512
					  $tracelevel)
8513
						if defined $::RD_TRACE;
8514
		$lastsep = "";
8515
		$expectation->is(q{})->at($text);
8516
 
8517
 
8518
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "("; 1 } and
8519
		     substr($text,0,length($_tok)) eq $_tok and
8520
		     do { substr($text,0,length($_tok)) = ""; 1; }
8521
		)
8522
		{
8523
 
8524
			$expectation->failed();
8525
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
8526
						  Parse::RecDescent::_tracefirst($text))
8527
							if defined $::RD_TRACE;
8528
			last;
8529
		}
8530
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
8531
						. $_tok . q{])},
8532
						  Parse::RecDescent::_tracefirst($text))
8533
							if defined $::RD_TRACE;
8534
		push @item, $item{__STRING1__}=$_tok;
8535
 
8536
 
8537
		Parse::RecDescent::_trace(q{Trying repeated subrule: [part]},
8538
				  Parse::RecDescent::_tracefirst($text),
8539
				  q{bodystructure},
8540
				  $tracelevel)
8541
					if defined $::RD_TRACE;
8542
		$expectation->is(q{part})->at($text);
8543
 
8544
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::part, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
8545
		{
8546
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [part]>>},
8547
						  Parse::RecDescent::_tracefirst($text),
8548
						  q{bodystructure},
8549
						  $tracelevel)
8550
							if defined $::RD_TRACE;
8551
			last;
8552
		}
8553
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [part]<< (}
8554
					. @$_tok . q{ times)},
8555
 
8556
					  Parse::RecDescent::_tracefirst($text),
8557
					  q{bodystructure},
8558
					  $tracelevel)
8559
						if defined $::RD_TRACE;
8560
		$item{q{part(s)}} = $_tok;
8561
		push @item, $_tok;
8562
 
8563
 
8564
 
8565
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
8566
					  Parse::RecDescent::_tracefirst($text),
8567
					  q{bodystructure},
8568
					  $tracelevel)
8569
						if defined $::RD_TRACE;
8570
		$lastsep = "";
8571
		$expectation->is(q{')'})->at($text);
8572
 
8573
 
8574
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
8575
		     substr($text,0,length($_tok)) eq $_tok and
8576
		     do { substr($text,0,length($_tok)) = ""; 1; }
8577
		)
8578
		{
8579
 
8580
			$expectation->failed();
8581
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
8582
						  Parse::RecDescent::_tracefirst($text))
8583
							if defined $::RD_TRACE;
8584
			last;
8585
		}
8586
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
8587
						. $_tok . q{])},
8588
						  Parse::RecDescent::_tracefirst($text))
8589
							if defined $::RD_TRACE;
8590
		push @item, $item{__STRING2__}=$_tok;
8591
 
8592
 
8593
		Parse::RecDescent::_trace(q{Trying action},
8594
					  Parse::RecDescent::_tracefirst($text),
8595
					  q{bodystructure},
8596
					  $tracelevel)
8597
						if defined $::RD_TRACE;
8598
 
8599
 
8600
		$_tok = ($_noactions) ? 0 : do {
8601
			$return = $item{'part(s)'} ;
8602
			$return||defined($return);
8603
		};
8604
		unless (defined $_tok)
8605
		{
8606
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
8607
					if defined $::RD_TRACE;
8608
			last;
8609
		}
8610
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
8611
					  . $_tok . q{])},
8612
					  Parse::RecDescent::_tracefirst($text))
8613
						if defined $::RD_TRACE;
8614
		push @item, $_tok;
8615
		$item{__ACTION1__}=$_tok;
8616
 
8617
 
8618
 
8619
		Parse::RecDescent::_trace(q{>>Matched production: ['(' part ')']<<},
8620
					  Parse::RecDescent::_tracefirst($text),
8621
					  q{bodystructure},
8622
					  $tracelevel)
8623
						if defined $::RD_TRACE;
8624
		$_matched = 1;
8625
		last;
8626
	}
8627
 
8628
		splice
8629
				@{$thisparser->{deferred}}, $def_at unless $_matched;
8630
 
8631
        unless ( $_matched || defined($score) )
8632
	{
8633
				splice @{$thisparser->{deferred}}, $def_at;
8634
 
8635
 
8636
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
8637
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
8638
					 Parse::RecDescent::_tracefirst($_[1]),
8639
					 q{bodystructure},
8640
					 $tracelevel)
8641
					if defined $::RD_TRACE;
8642
		return undef;
8643
	}
8644
	if (!defined($return) && defined($score))
8645
	{
8646
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
8647
					  q{bodystructure},
8648
					  $tracelevel)
8649
						if defined $::RD_TRACE;
8650
		$return = $score_return;
8651
	}
8652
	splice @{$thisparser->{errors}}, $err_at;
8653
	$return = $item[$#item] unless defined $return;
8654
	if (defined $::RD_TRACE)
8655
	{
8656
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
8657
					  $return . q{])}, "",
8658
					  q{bodystructure},
8659
					  $tracelevel);
8660
		Parse::RecDescent::_trace(q{(consumed: [} .
8661
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
8662
					  Parse::RecDescent::_tracefirst($text),
8663
					  , q{bodystructure},
8664
					  $tracelevel)
8665
	}
8666
	$_[1] = $text;
8667
	return $return;
8668
}
8669
 
8670
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
8671
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::PLAIN
8672
{
8673
	my $thisparser = $_[0];
8674
	use vars q{$tracelevel};
8675
	local $tracelevel = ($tracelevel||0)+1;
8676
	$ERRORS = 0;
8677
	my $thisrule = $thisparser->{"rules"}{"PLAIN"};
8678
 
8679
	Parse::RecDescent::_trace(q{Trying rule: [PLAIN]},
8680
				  Parse::RecDescent::_tracefirst($_[1]),
8681
				  q{PLAIN},
8682
				  $tracelevel)
8683
					if defined $::RD_TRACE;
8684
 
8685
	my $def_at = @{$thisparser->{deferred}};
8686
	my $err_at = @{$thisparser->{errors}};
8687
 
8688
	my $score;
8689
	my $score_return;
8690
	my $_tok;
8691
	my $return = undef;
8692
	my $_matched=0;
8693
	my $commit=0;
8694
	my @item = ();
8695
	my %item = ();
8696
	my $repeating =  defined($_[2]) && $_[2];
8697
	my $_noactions = defined($_[3]) && $_[3];
8698
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
8699
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
8700
	my $text;
8701
	my $lastsep="";
8702
    my $expectation = new Parse::RecDescent::Expectation(q{/^"PLAIN"|^PLAIN/i});
8703
	$expectation->at($_[1]);
8704
 
8705
	my $thisline;
8706
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
8707
 
8708
 
8709
 
8710
	while (!$_matched && !$commit)
8711
	{
8712
 
8713
		Parse::RecDescent::_trace(q{Trying production: [/^"PLAIN"|^PLAIN/i]},
8714
					  Parse::RecDescent::_tracefirst($_[1]),
8715
					  q{PLAIN},
8716
					  $tracelevel)
8717
						if defined $::RD_TRACE;
8718
		my $thisprod = $thisrule->{"prods"}[0];
8719
		$text = $_[1];
8720
		my $_savetext;
8721
		@item = (q{PLAIN});
8722
		%item = (__RULE__ => q{PLAIN});
8723
		my $repcount = 0;
8724
 
8725
 
8726
		Parse::RecDescent::_trace(q{Trying terminal: [/^"PLAIN"|^PLAIN/i]}, Parse::RecDescent::_tracefirst($text),
8727
					  q{PLAIN},
8728
					  $tracelevel)
8729
						if defined $::RD_TRACE;
8730
		$lastsep = "";
8731
		$expectation->is(q{})->at($text);
8732
 
8733
 
8734
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:^"PLAIN"|^PLAIN)//i)
8735
		{
8736
 
8737
			$expectation->failed();
8738
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
8739
						  Parse::RecDescent::_tracefirst($text))
8740
					if defined $::RD_TRACE;
8741
 
8742
			last;
8743
		}
8744
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
8745
						. $& . q{])},
8746
						  Parse::RecDescent::_tracefirst($text))
8747
					if defined $::RD_TRACE;
8748
		push @item, $item{__PATTERN1__}=$&;
8749
 
8750
 
8751
		Parse::RecDescent::_trace(q{Trying action},
8752
					  Parse::RecDescent::_tracefirst($text),
8753
					  q{PLAIN},
8754
					  $tracelevel)
8755
						if defined $::RD_TRACE;
8756
 
8757
 
8758
		$_tok = ($_noactions) ? 0 : do { $return = "PLAIN" };
8759
		unless (defined $_tok)
8760
		{
8761
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
8762
					if defined $::RD_TRACE;
8763
			last;
8764
		}
8765
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
8766
					  . $_tok . q{])},
8767
					  Parse::RecDescent::_tracefirst($text))
8768
						if defined $::RD_TRACE;
8769
		push @item, $_tok;
8770
		$item{__ACTION1__}=$_tok;
8771
 
8772
 
8773
 
8774
		Parse::RecDescent::_trace(q{>>Matched production: [/^"PLAIN"|^PLAIN/i]<<},
8775
					  Parse::RecDescent::_tracefirst($text),
8776
					  q{PLAIN},
8777
					  $tracelevel)
8778
						if defined $::RD_TRACE;
8779
		$_matched = 1;
8780
		last;
8781
	}
8782
 
8783
		splice
8784
				@{$thisparser->{deferred}}, $def_at unless $_matched;
8785
 
8786
        unless ( $_matched || defined($score) )
8787
	{
8788
				splice @{$thisparser->{deferred}}, $def_at;
8789
 
8790
 
8791
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
8792
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
8793
					 Parse::RecDescent::_tracefirst($_[1]),
8794
					 q{PLAIN},
8795
					 $tracelevel)
8796
					if defined $::RD_TRACE;
8797
		return undef;
8798
	}
8799
	if (!defined($return) && defined($score))
8800
	{
8801
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
8802
					  q{PLAIN},
8803
					  $tracelevel)
8804
						if defined $::RD_TRACE;
8805
		$return = $score_return;
8806
	}
8807
	splice @{$thisparser->{errors}}, $err_at;
8808
	$return = $item[$#item] unless defined $return;
8809
	if (defined $::RD_TRACE)
8810
	{
8811
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
8812
					  $return . q{])}, "",
8813
					  q{PLAIN},
8814
					  $tracelevel);
8815
		Parse::RecDescent::_trace(q{(consumed: [} .
8816
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
8817
					  Parse::RecDescent::_tracefirst($text),
8818
					  , q{PLAIN},
8819
					  $tracelevel)
8820
	}
8821
	$_[1] = $text;
8822
	return $return;
8823
}
8824
 
8825
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
8826
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NUMBER
8827
{
8828
	my $thisparser = $_[0];
8829
	use vars q{$tracelevel};
8830
	local $tracelevel = ($tracelevel||0)+1;
8831
	$ERRORS = 0;
8832
	my $thisrule = $thisparser->{"rules"}{"NUMBER"};
8833
 
8834
	Parse::RecDescent::_trace(q{Trying rule: [NUMBER]},
8835
				  Parse::RecDescent::_tracefirst($_[1]),
8836
				  q{NUMBER},
8837
				  $tracelevel)
8838
					if defined $::RD_TRACE;
8839
 
8840
	my $def_at = @{$thisparser->{deferred}};
8841
	my $err_at = @{$thisparser->{errors}};
8842
 
8843
	my $score;
8844
	my $score_return;
8845
	my $_tok;
8846
	my $return = undef;
8847
	my $_matched=0;
8848
	my $commit=0;
8849
	my @item = ();
8850
	my %item = ();
8851
	my $repeating =  defined($_[2]) && $_[2];
8852
	my $_noactions = defined($_[3]) && $_[3];
8853
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
8854
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
8855
	my $text;
8856
	my $lastsep="";
8857
    my $expectation = new Parse::RecDescent::Expectation(q{/^(\\d+)/});
8858
	$expectation->at($_[1]);
8859
 
8860
	my $thisline;
8861
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
8862
 
8863
 
8864
 
8865
	while (!$_matched && !$commit)
8866
	{
8867
 
8868
		Parse::RecDescent::_trace(q{Trying production: [/^(\\d+)/]},
8869
					  Parse::RecDescent::_tracefirst($_[1]),
8870
					  q{NUMBER},
8871
					  $tracelevel)
8872
						if defined $::RD_TRACE;
8873
		my $thisprod = $thisrule->{"prods"}[0];
8874
		$text = $_[1];
8875
		my $_savetext;
8876
		@item = (q{NUMBER});
8877
		%item = (__RULE__ => q{NUMBER});
8878
		my $repcount = 0;
8879
 
8880
 
8881
		Parse::RecDescent::_trace(q{Trying terminal: [/^(\\d+)/]}, Parse::RecDescent::_tracefirst($text),
8882
					  q{NUMBER},
8883
					  $tracelevel)
8884
						if defined $::RD_TRACE;
8885
		$lastsep = "";
8886
		$expectation->is(q{})->at($text);
8887
 
8888
 
8889
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:^(\d+))//)
8890
		{
8891
 
8892
			$expectation->failed();
8893
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
8894
						  Parse::RecDescent::_tracefirst($text))
8895
					if defined $::RD_TRACE;
8896
 
8897
			last;
8898
		}
8899
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
8900
						. $& . q{])},
8901
						  Parse::RecDescent::_tracefirst($text))
8902
					if defined $::RD_TRACE;
8903
		push @item, $item{__PATTERN1__}=$&;
8904
 
8905
 
8906
		Parse::RecDescent::_trace(q{Trying action},
8907
					  Parse::RecDescent::_tracefirst($text),
8908
					  q{NUMBER},
8909
					  $tracelevel)
8910
						if defined $::RD_TRACE;
8911
 
8912
 
8913
		$_tok = ($_noactions) ? 0 : do { $return = $item[1]; $return||defined($return);};
8914
		unless (defined $_tok)
8915
		{
8916
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
8917
					if defined $::RD_TRACE;
8918
			last;
8919
		}
8920
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
8921
					  . $_tok . q{])},
8922
					  Parse::RecDescent::_tracefirst($text))
8923
						if defined $::RD_TRACE;
8924
		push @item, $_tok;
8925
		$item{__ACTION1__}=$_tok;
8926
 
8927
 
8928
 
8929
		Parse::RecDescent::_trace(q{>>Matched production: [/^(\\d+)/]<<},
8930
					  Parse::RecDescent::_tracefirst($text),
8931
					  q{NUMBER},
8932
					  $tracelevel)
8933
						if defined $::RD_TRACE;
8934
		$_matched = 1;
8935
		last;
8936
	}
8937
 
8938
		splice
8939
				@{$thisparser->{deferred}}, $def_at unless $_matched;
8940
 
8941
        unless ( $_matched || defined($score) )
8942
	{
8943
				splice @{$thisparser->{deferred}}, $def_at;
8944
 
8945
 
8946
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
8947
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
8948
					 Parse::RecDescent::_tracefirst($_[1]),
8949
					 q{NUMBER},
8950
					 $tracelevel)
8951
					if defined $::RD_TRACE;
8952
		return undef;
8953
	}
8954
	if (!defined($return) && defined($score))
8955
	{
8956
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
8957
					  q{NUMBER},
8958
					  $tracelevel)
8959
						if defined $::RD_TRACE;
8960
		$return = $score_return;
8961
	}
8962
	splice @{$thisparser->{errors}}, $err_at;
8963
	$return = $item[$#item] unless defined $return;
8964
	if (defined $::RD_TRACE)
8965
	{
8966
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
8967
					  $return . q{])}, "",
8968
					  q{NUMBER},
8969
					  $tracelevel);
8970
		Parse::RecDescent::_trace(q{(consumed: [} .
8971
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
8972
					  Parse::RecDescent::_tracefirst($text),
8973
					  , q{NUMBER},
8974
					  $tracelevel)
8975
	}
8976
	$_[1] = $text;
8977
	return $return;
8978
}
8979
 
8980
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
8981
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::HTML
8982
{
8983
	my $thisparser = $_[0];
8984
	use vars q{$tracelevel};
8985
	local $tracelevel = ($tracelevel||0)+1;
8986
	$ERRORS = 0;
8987
	my $thisrule = $thisparser->{"rules"}{"HTML"};
8988
 
8989
	Parse::RecDescent::_trace(q{Trying rule: [HTML]},
8990
				  Parse::RecDescent::_tracefirst($_[1]),
8991
				  q{HTML},
8992
				  $tracelevel)
8993
					if defined $::RD_TRACE;
8994
 
8995
	my $def_at = @{$thisparser->{deferred}};
8996
	my $err_at = @{$thisparser->{errors}};
8997
 
8998
	my $score;
8999
	my $score_return;
9000
	my $_tok;
9001
	my $return = undef;
9002
	my $_matched=0;
9003
	my $commit=0;
9004
	my @item = ();
9005
	my %item = ();
9006
	my $repeating =  defined($_[2]) && $_[2];
9007
	my $_noactions = defined($_[3]) && $_[3];
9008
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
9009
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
9010
	my $text;
9011
	my $lastsep="";
9012
    my $expectation = new Parse::RecDescent::Expectation(q{/"HTML"|HTML/i});
9013
	$expectation->at($_[1]);
9014
 
9015
	my $thisline;
9016
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
9017
 
9018
 
9019
 
9020
	while (!$_matched && !$commit)
9021
	{
9022
 
9023
		Parse::RecDescent::_trace(q{Trying production: [/"HTML"|HTML/i]},
9024
					  Parse::RecDescent::_tracefirst($_[1]),
9025
					  q{HTML},
9026
					  $tracelevel)
9027
						if defined $::RD_TRACE;
9028
		my $thisprod = $thisrule->{"prods"}[0];
9029
		$text = $_[1];
9030
		my $_savetext;
9031
		@item = (q{HTML});
9032
		%item = (__RULE__ => q{HTML});
9033
		my $repcount = 0;
9034
 
9035
 
9036
		Parse::RecDescent::_trace(q{Trying terminal: [/"HTML"|HTML/i]}, Parse::RecDescent::_tracefirst($text),
9037
					  q{HTML},
9038
					  $tracelevel)
9039
						if defined $::RD_TRACE;
9040
		$lastsep = "";
9041
		$expectation->is(q{})->at($text);
9042
 
9043
 
9044
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:"HTML"|HTML)//i)
9045
		{
9046
 
9047
			$expectation->failed();
9048
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
9049
						  Parse::RecDescent::_tracefirst($text))
9050
					if defined $::RD_TRACE;
9051
 
9052
			last;
9053
		}
9054
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
9055
						. $& . q{])},
9056
						  Parse::RecDescent::_tracefirst($text))
9057
					if defined $::RD_TRACE;
9058
		push @item, $item{__PATTERN1__}=$&;
9059
 
9060
 
9061
		Parse::RecDescent::_trace(q{Trying action},
9062
					  Parse::RecDescent::_tracefirst($text),
9063
					  q{HTML},
9064
					  $tracelevel)
9065
						if defined $::RD_TRACE;
9066
 
9067
 
9068
		$_tok = ($_noactions) ? 0 : do { $return = "HTML" };
9069
		unless (defined $_tok)
9070
		{
9071
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
9072
					if defined $::RD_TRACE;
9073
			last;
9074
		}
9075
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
9076
					  . $_tok . q{])},
9077
					  Parse::RecDescent::_tracefirst($text))
9078
						if defined $::RD_TRACE;
9079
		push @item, $_tok;
9080
		$item{__ACTION1__}=$_tok;
9081
 
9082
 
9083
 
9084
		Parse::RecDescent::_trace(q{>>Matched production: [/"HTML"|HTML/i]<<},
9085
					  Parse::RecDescent::_tracefirst($text),
9086
					  q{HTML},
9087
					  $tracelevel)
9088
						if defined $::RD_TRACE;
9089
		$_matched = 1;
9090
		last;
9091
	}
9092
 
9093
		splice
9094
				@{$thisparser->{deferred}}, $def_at unless $_matched;
9095
 
9096
        unless ( $_matched || defined($score) )
9097
	{
9098
				splice @{$thisparser->{deferred}}, $def_at;
9099
 
9100
 
9101
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
9102
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
9103
					 Parse::RecDescent::_tracefirst($_[1]),
9104
					 q{HTML},
9105
					 $tracelevel)
9106
					if defined $::RD_TRACE;
9107
		return undef;
9108
	}
9109
	if (!defined($return) && defined($score))
9110
	{
9111
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
9112
					  q{HTML},
9113
					  $tracelevel)
9114
						if defined $::RD_TRACE;
9115
		$return = $score_return;
9116
	}
9117
	splice @{$thisparser->{errors}}, $err_at;
9118
	$return = $item[$#item] unless defined $return;
9119
	if (defined $::RD_TRACE)
9120
	{
9121
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
9122
					  $return . q{])}, "",
9123
					  q{HTML},
9124
					  $tracelevel);
9125
		Parse::RecDescent::_trace(q{(consumed: [} .
9126
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
9127
					  Parse::RecDescent::_tracefirst($text),
9128
					  , q{HTML},
9129
					  $tracelevel)
9130
	}
9131
	$_[1] = $text;
9132
	return $return;
9133
}
9134
 
9135
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
9136
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodydisp
9137
{
9138
	my $thisparser = $_[0];
9139
	use vars q{$tracelevel};
9140
	local $tracelevel = ($tracelevel||0)+1;
9141
	$ERRORS = 0;
9142
	my $thisrule = $thisparser->{"rules"}{"bodydisp"};
9143
 
9144
	Parse::RecDescent::_trace(q{Trying rule: [bodydisp]},
9145
				  Parse::RecDescent::_tracefirst($_[1]),
9146
				  q{bodydisp},
9147
				  $tracelevel)
9148
					if defined $::RD_TRACE;
9149
 
9150
	my $def_at = @{$thisparser->{deferred}};
9151
	my $err_at = @{$thisparser->{errors}};
9152
 
9153
	my $score;
9154
	my $score_return;
9155
	my $_tok;
9156
	my $return = undef;
9157
	my $_matched=0;
9158
	my $commit=0;
9159
	my @item = ();
9160
	my %item = ();
9161
	my $repeating =  defined($_[2]) && $_[2];
9162
	my $_noactions = defined($_[3]) && $_[3];
9163
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
9164
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
9165
	my $text;
9166
	my $lastsep="";
9167
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or '('});
9168
	$expectation->at($_[1]);
9169
 
9170
	my $thisline;
9171
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
9172
 
9173
 
9174
 
9175
	while (!$_matched && !$commit)
9176
	{
9177
 
9178
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
9179
					  Parse::RecDescent::_tracefirst($_[1]),
9180
					  q{bodydisp},
9181
					  $tracelevel)
9182
						if defined $::RD_TRACE;
9183
		my $thisprod = $thisrule->{"prods"}[0];
9184
		$text = $_[1];
9185
		my $_savetext;
9186
		@item = (q{bodydisp});
9187
		%item = (__RULE__ => q{bodydisp});
9188
		my $repcount = 0;
9189
 
9190
 
9191
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
9192
				  Parse::RecDescent::_tracefirst($text),
9193
				  q{bodydisp},
9194
				  $tracelevel)
9195
					if defined $::RD_TRACE;
9196
		if (1) { no strict qw{refs};
9197
		$expectation->is(q{})->at($text);
9198
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
9199
		{
9200
 
9201
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
9202
						  Parse::RecDescent::_tracefirst($text),
9203
						  q{bodydisp},
9204
						  $tracelevel)
9205
							if defined $::RD_TRACE;
9206
			$expectation->failed();
9207
			last;
9208
		}
9209
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
9210
					. $_tok . q{]},
9211
 
9212
					  Parse::RecDescent::_tracefirst($text),
9213
					  q{bodydisp},
9214
					  $tracelevel)
9215
						if defined $::RD_TRACE;
9216
		$item{q{NIL}} = $_tok;
9217
		push @item, $_tok;
9218
 
9219
		}
9220
 
9221
 
9222
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
9223
					  Parse::RecDescent::_tracefirst($text),
9224
					  q{bodydisp},
9225
					  $tracelevel)
9226
						if defined $::RD_TRACE;
9227
		$_matched = 1;
9228
		last;
9229
	}
9230
 
9231
		splice
9232
				@{$thisparser->{deferred}}, $def_at unless $_matched;
9233
 
9234
	while (!$_matched && !$commit)
9235
	{
9236
 
9237
		Parse::RecDescent::_trace(q{Trying production: ['(' kvpair ')']},
9238
					  Parse::RecDescent::_tracefirst($_[1]),
9239
					  q{bodydisp},
9240
					  $tracelevel)
9241
						if defined $::RD_TRACE;
9242
		my $thisprod = $thisrule->{"prods"}[1];
9243
		$text = $_[1];
9244
		my $_savetext;
9245
		@item = (q{bodydisp});
9246
		%item = (__RULE__ => q{bodydisp});
9247
		my $repcount = 0;
9248
 
9249
 
9250
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
9251
					  Parse::RecDescent::_tracefirst($text),
9252
					  q{bodydisp},
9253
					  $tracelevel)
9254
						if defined $::RD_TRACE;
9255
		$lastsep = "";
9256
		$expectation->is(q{})->at($text);
9257
 
9258
 
9259
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A\(//)
9260
		{
9261
 
9262
			$expectation->failed();
9263
			Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
9264
						  Parse::RecDescent::_tracefirst($text))
9265
							if defined $::RD_TRACE;
9266
			last;
9267
		}
9268
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
9269
						. $& . q{])},
9270
						  Parse::RecDescent::_tracefirst($text))
9271
							if defined $::RD_TRACE;
9272
		push @item, $item{__STRING1__}=$&;
9273
 
9274
 
9275
		Parse::RecDescent::_trace(q{Trying repeated subrule: [kvpair]},
9276
				  Parse::RecDescent::_tracefirst($text),
9277
				  q{bodydisp},
9278
				  $tracelevel)
9279
					if defined $::RD_TRACE;
9280
		$expectation->is(q{kvpair})->at($text);
9281
 
9282
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::kvpair, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
9283
		{
9284
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [kvpair]>>},
9285
						  Parse::RecDescent::_tracefirst($text),
9286
						  q{bodydisp},
9287
						  $tracelevel)
9288
							if defined $::RD_TRACE;
9289
			last;
9290
		}
9291
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [kvpair]<< (}
9292
					. @$_tok . q{ times)},
9293
 
9294
					  Parse::RecDescent::_tracefirst($text),
9295
					  q{bodydisp},
9296
					  $tracelevel)
9297
						if defined $::RD_TRACE;
9298
		$item{q{kvpair(s)}} = $_tok;
9299
		push @item, $_tok;
9300
 
9301
 
9302
 
9303
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
9304
					  Parse::RecDescent::_tracefirst($text),
9305
					  q{bodydisp},
9306
					  $tracelevel)
9307
						if defined $::RD_TRACE;
9308
		$lastsep = "";
9309
		$expectation->is(q{')'})->at($text);
9310
 
9311
 
9312
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A\)//)
9313
		{
9314
 
9315
			$expectation->failed();
9316
			Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
9317
						  Parse::RecDescent::_tracefirst($text))
9318
							if defined $::RD_TRACE;
9319
			last;
9320
		}
9321
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
9322
						. $& . q{])},
9323
						  Parse::RecDescent::_tracefirst($text))
9324
							if defined $::RD_TRACE;
9325
		push @item, $item{__STRING2__}=$&;
9326
 
9327
 
9328
		Parse::RecDescent::_trace(q{Trying action},
9329
					  Parse::RecDescent::_tracefirst($text),
9330
					  q{bodydisp},
9331
					  $tracelevel)
9332
						if defined $::RD_TRACE;
9333
 
9334
 
9335
		$_tok = ($_noactions) ? 0 : do {
9336
                          $return = $item{NIL} || 
9337
                                    { map { (%$_) } @{$item{'kvpair(s)'}} };
9338
                          $return || defined($return); 
9339
                        };
9340
		unless (defined $_tok)
9341
		{
9342
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
9343
					if defined $::RD_TRACE;
9344
			last;
9345
		}
9346
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
9347
					  . $_tok . q{])},
9348
					  Parse::RecDescent::_tracefirst($text))
9349
						if defined $::RD_TRACE;
9350
		push @item, $_tok;
9351
		$item{__ACTION1__}=$_tok;
9352
 
9353
 
9354
 
9355
		Parse::RecDescent::_trace(q{>>Matched production: ['(' kvpair ')']<<},
9356
					  Parse::RecDescent::_tracefirst($text),
9357
					  q{bodydisp},
9358
					  $tracelevel)
9359
						if defined $::RD_TRACE;
9360
		$_matched = 1;
9361
		last;
9362
	}
9363
 
9364
		splice
9365
				@{$thisparser->{deferred}}, $def_at unless $_matched;
9366
 
9367
        unless ( $_matched || defined($score) )
9368
	{
9369
				splice @{$thisparser->{deferred}}, $def_at;
9370
 
9371
 
9372
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
9373
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
9374
					 Parse::RecDescent::_tracefirst($_[1]),
9375
					 q{bodydisp},
9376
					 $tracelevel)
9377
					if defined $::RD_TRACE;
9378
		return undef;
9379
	}
9380
	if (!defined($return) && defined($score))
9381
	{
9382
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
9383
					  q{bodydisp},
9384
					  $tracelevel)
9385
						if defined $::RD_TRACE;
9386
		$return = $score_return;
9387
	}
9388
	splice @{$thisparser->{errors}}, $err_at;
9389
	$return = $item[$#item] unless defined $return;
9390
	if (defined $::RD_TRACE)
9391
	{
9392
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
9393
					  $return . q{])}, "",
9394
					  q{bodydisp},
9395
					  $tracelevel);
9396
		Parse::RecDescent::_trace(q{(consumed: [} .
9397
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
9398
					  Parse::RecDescent::_tracefirst($text),
9399
					  , q{bodydisp},
9400
					  $tracelevel)
9401
	}
9402
	$_[1] = $text;
9403
	return $return;
9404
}
9405
 
9406
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
9407
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::part
9408
{
9409
	my $thisparser = $_[0];
9410
	use vars q{$tracelevel};
9411
	local $tracelevel = ($tracelevel||0)+1;
9412
	$ERRORS = 0;
9413
	my $thisrule = $thisparser->{"rules"}{"part"};
9414
 
9415
	Parse::RecDescent::_trace(q{Trying rule: [part]},
9416
				  Parse::RecDescent::_tracefirst($_[1]),
9417
				  q{part},
9418
				  $tracelevel)
9419
					if defined $::RD_TRACE;
9420
 
9421
	my $def_at = @{$thisparser->{deferred}};
9422
	my $err_at = @{$thisparser->{errors}};
9423
 
9424
	my $score;
9425
	my $score_return;
9426
	my $_tok;
9427
	my $return = undef;
9428
	my $_matched=0;
9429
	my $commit=0;
9430
	my @item = ();
9431
	my %item = ();
9432
	my $repeating =  defined($_[2]) && $_[2];
9433
	my $_noactions = defined($_[3]) && $_[3];
9434
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
9435
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
9436
	my $text;
9437
	my $lastsep="";
9438
    my $expectation = new Parse::RecDescent::Expectation(q{subpart, or textmessage, or messagerfc822message, or othertypemessage});
9439
	$expectation->at($_[1]);
9440
 
9441
	my $thisline;
9442
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
9443
 
9444
 
9445
 
9446
	while (!$_matched && !$commit)
9447
	{
9448
 
9449
		Parse::RecDescent::_trace(q{Trying production: [subpart <commit> basicfields bodyparms bodydisp bodylang <defer:{  $subpartCount = 0 }>]},
9450
					  Parse::RecDescent::_tracefirst($_[1]),
9451
					  q{part},
9452
					  $tracelevel)
9453
						if defined $::RD_TRACE;
9454
		my $thisprod = $thisrule->{"prods"}[0];
9455
		$text = $_[1];
9456
		my $_savetext;
9457
		@item = (q{part});
9458
		%item = (__RULE__ => q{part});
9459
		my $repcount = 0;
9460
 
9461
 
9462
		Parse::RecDescent::_trace(q{Trying repeated subrule: [subpart]},
9463
				  Parse::RecDescent::_tracefirst($text),
9464
				  q{part},
9465
				  $tracelevel)
9466
					if defined $::RD_TRACE;
9467
		$expectation->is(q{})->at($text);
9468
 
9469
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::subpart, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
9470
		{
9471
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [subpart]>>},
9472
						  Parse::RecDescent::_tracefirst($text),
9473
						  q{part},
9474
						  $tracelevel)
9475
							if defined $::RD_TRACE;
9476
			last;
9477
		}
9478
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [subpart]<< (}
9479
					. @$_tok . q{ times)},
9480
 
9481
					  Parse::RecDescent::_tracefirst($text),
9482
					  q{part},
9483
					  $tracelevel)
9484
						if defined $::RD_TRACE;
9485
		$item{q{subpart(s)}} = $_tok;
9486
		push @item, $_tok;
9487
 
9488
 
9489
 
9490
 
9491
 
9492
		Parse::RecDescent::_trace(q{Trying directive: [<commit>]},
9493
					Parse::RecDescent::_tracefirst($text),
9494
					  q{part},
9495
					  $tracelevel)
9496
						if defined $::RD_TRACE; 
9497
		$_tok = do { $commit = 1 };
9498
		if (defined($_tok))
9499
		{
9500
			Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
9501
						. $_tok . q{])},
9502
						Parse::RecDescent::_tracefirst($text))
9503
							if defined $::RD_TRACE;
9504
		}
9505
		else
9506
		{
9507
			Parse::RecDescent::_trace(q{<<Didn't match directive>>},
9508
						Parse::RecDescent::_tracefirst($text))
9509
							if defined $::RD_TRACE;
9510
		}
9511
 
9512
		last unless defined $_tok;
9513
		push @item, $item{__DIRECTIVE1__}=$_tok;
9514
 
9515
 
9516
		Parse::RecDescent::_trace(q{Trying subrule: [basicfields]},
9517
				  Parse::RecDescent::_tracefirst($text),
9518
				  q{part},
9519
				  $tracelevel)
9520
					if defined $::RD_TRACE;
9521
		if (1) { no strict qw{refs};
9522
		$expectation->is(q{basicfields})->at($text);
9523
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::basicfields($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
9524
		{
9525
 
9526
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [basicfields]>>},
9527
						  Parse::RecDescent::_tracefirst($text),
9528
						  q{part},
9529
						  $tracelevel)
9530
							if defined $::RD_TRACE;
9531
			$expectation->failed();
9532
			last;
9533
		}
9534
		Parse::RecDescent::_trace(q{>>Matched subrule: [basicfields]<< (return value: [}
9535
					. $_tok . q{]},
9536
 
9537
					  Parse::RecDescent::_tracefirst($text),
9538
					  q{part},
9539
					  $tracelevel)
9540
						if defined $::RD_TRACE;
9541
		$item{q{basicfields}} = $_tok;
9542
		push @item, $_tok;
9543
 
9544
		}
9545
 
9546
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodyparms]},
9547
				  Parse::RecDescent::_tracefirst($text),
9548
				  q{part},
9549
				  $tracelevel)
9550
					if defined $::RD_TRACE;
9551
		$expectation->is(q{bodyparms})->at($text);
9552
 
9553
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodyparms, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
9554
		{
9555
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodyparms]>>},
9556
						  Parse::RecDescent::_tracefirst($text),
9557
						  q{part},
9558
						  $tracelevel)
9559
							if defined $::RD_TRACE;
9560
			last;
9561
		}
9562
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodyparms]<< (}
9563
					. @$_tok . q{ times)},
9564
 
9565
					  Parse::RecDescent::_tracefirst($text),
9566
					  q{part},
9567
					  $tracelevel)
9568
						if defined $::RD_TRACE;
9569
		$item{q{bodyparms(?)}} = $_tok;
9570
		push @item, $_tok;
9571
 
9572
 
9573
 
9574
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodydisp]},
9575
				  Parse::RecDescent::_tracefirst($text),
9576
				  q{part},
9577
				  $tracelevel)
9578
					if defined $::RD_TRACE;
9579
		$expectation->is(q{bodydisp})->at($text);
9580
 
9581
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodydisp, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
9582
		{
9583
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodydisp]>>},
9584
						  Parse::RecDescent::_tracefirst($text),
9585
						  q{part},
9586
						  $tracelevel)
9587
							if defined $::RD_TRACE;
9588
			last;
9589
		}
9590
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodydisp]<< (}
9591
					. @$_tok . q{ times)},
9592
 
9593
					  Parse::RecDescent::_tracefirst($text),
9594
					  q{part},
9595
					  $tracelevel)
9596
						if defined $::RD_TRACE;
9597
		$item{q{bodydisp(?)}} = $_tok;
9598
		push @item, $_tok;
9599
 
9600
 
9601
 
9602
		Parse::RecDescent::_trace(q{Trying repeated subrule: [bodylang]},
9603
				  Parse::RecDescent::_tracefirst($text),
9604
				  q{part},
9605
				  $tracelevel)
9606
					if defined $::RD_TRACE;
9607
		$expectation->is(q{bodylang})->at($text);
9608
 
9609
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodylang, 0, 1, $_noactions,$expectation,sub { \@arg }))) 
9610
		{
9611
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [bodylang]>>},
9612
						  Parse::RecDescent::_tracefirst($text),
9613
						  q{part},
9614
						  $tracelevel)
9615
							if defined $::RD_TRACE;
9616
			last;
9617
		}
9618
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [bodylang]<< (}
9619
					. @$_tok . q{ times)},
9620
 
9621
					  Parse::RecDescent::_tracefirst($text),
9622
					  q{part},
9623
					  $tracelevel)
9624
						if defined $::RD_TRACE;
9625
		$item{q{bodylang(?)}} = $_tok;
9626
		push @item, $_tok;
9627
 
9628
 
9629
 
9630
 
9631
 
9632
		Parse::RecDescent::_trace(q{Trying directive: [<defer:{  $subpartCount = 0 }>]},
9633
					Parse::RecDescent::_tracefirst($text),
9634
					  q{part},
9635
					  $tracelevel)
9636
						if defined $::RD_TRACE; 
9637
		$_tok = do { push @{$thisparser->{deferred}}, sub {  $subpartCount = 0 }; };
9638
		if (defined($_tok))
9639
		{
9640
			Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
9641
						. $_tok . q{])},
9642
						Parse::RecDescent::_tracefirst($text))
9643
							if defined $::RD_TRACE;
9644
		}
9645
		else
9646
		{
9647
			Parse::RecDescent::_trace(q{<<Didn't match directive>>},
9648
						Parse::RecDescent::_tracefirst($text))
9649
							if defined $::RD_TRACE;
9650
		}
9651
 
9652
		last unless defined $_tok;
9653
		push @item, $item{__DIRECTIVE2__}=$_tok;
9654
 
9655
 
9656
		Parse::RecDescent::_trace(q{Trying action},
9657
					  Parse::RecDescent::_tracefirst($text),
9658
					  q{part},
9659
					  $tracelevel)
9660
						if defined $::RD_TRACE;
9661
 
9662
 
9663
		$_tok = ($_noactions) ? 0 : do {
9664
		$return = bless($item{basicfields}, 
9665
			"Mail::IMAPClient::BodyStructure");
9666
		$return->{bodytype} = "MULTIPART";
9667
		$return->{bodystructure} = $item{'subpart(s)'};
9668
		foreach my $b (qw/bodyparms(?) bodydisp(?) bodylang(?)/) { 
9669
			my $k = $b; $k =~ s/\(\?\)$//;
9670
			$return->{$k} = ref($item{$b}) ? $item{$b}[0] : $item{$b};
9671
		}
9672
		$return||defined($return) ;
9673
	};
9674
		unless (defined $_tok)
9675
		{
9676
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
9677
					if defined $::RD_TRACE;
9678
			last;
9679
		}
9680
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
9681
					  . $_tok . q{])},
9682
					  Parse::RecDescent::_tracefirst($text))
9683
						if defined $::RD_TRACE;
9684
		push @item, $_tok;
9685
		$item{__ACTION1__}=$_tok;
9686
 
9687
 
9688
 
9689
		Parse::RecDescent::_trace(q{>>Matched production: [subpart <commit> basicfields bodyparms bodydisp bodylang <defer:{  $subpartCount = 0 }>]<<},
9690
					  Parse::RecDescent::_tracefirst($text),
9691
					  q{part},
9692
					  $tracelevel)
9693
						if defined $::RD_TRACE;
9694
		$_matched = 1;
9695
		last;
9696
	}
9697
 
9698
		splice
9699
				@{$thisparser->{deferred}}, $def_at unless $_matched;
9700
 
9701
	while (!$_matched && !$commit)
9702
	{
9703
 
9704
		Parse::RecDescent::_trace(q{Trying production: [textmessage]},
9705
					  Parse::RecDescent::_tracefirst($_[1]),
9706
					  q{part},
9707
					  $tracelevel)
9708
						if defined $::RD_TRACE;
9709
		my $thisprod = $thisrule->{"prods"}[1];
9710
		$text = $_[1];
9711
		my $_savetext;
9712
		@item = (q{part});
9713
		%item = (__RULE__ => q{part});
9714
		my $repcount = 0;
9715
 
9716
 
9717
		Parse::RecDescent::_trace(q{Trying subrule: [textmessage]},
9718
				  Parse::RecDescent::_tracefirst($text),
9719
				  q{part},
9720
				  $tracelevel)
9721
					if defined $::RD_TRACE;
9722
		if (1) { no strict qw{refs};
9723
		$expectation->is(q{})->at($text);
9724
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::textmessage($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
9725
		{
9726
 
9727
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [textmessage]>>},
9728
						  Parse::RecDescent::_tracefirst($text),
9729
						  q{part},
9730
						  $tracelevel)
9731
							if defined $::RD_TRACE;
9732
			$expectation->failed();
9733
			last;
9734
		}
9735
		Parse::RecDescent::_trace(q{>>Matched subrule: [textmessage]<< (return value: [}
9736
					. $_tok . q{]},
9737
 
9738
					  Parse::RecDescent::_tracefirst($text),
9739
					  q{part},
9740
					  $tracelevel)
9741
						if defined $::RD_TRACE;
9742
		$item{q{textmessage}} = $_tok;
9743
		push @item, $_tok;
9744
 
9745
		}
9746
 
9747
		Parse::RecDescent::_trace(q{Trying action},
9748
					  Parse::RecDescent::_tracefirst($text),
9749
					  q{part},
9750
					  $tracelevel)
9751
						if defined $::RD_TRACE;
9752
 
9753
 
9754
		$_tok = ($_noactions) ? 0 : do {
9755
		$return = bless $item{textmessage}, "Mail::IMAPClient::BodyStructure";
9756
		$return||defined($return);
9757
	};
9758
		unless (defined $_tok)
9759
		{
9760
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
9761
					if defined $::RD_TRACE;
9762
			last;
9763
		}
9764
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
9765
					  . $_tok . q{])},
9766
					  Parse::RecDescent::_tracefirst($text))
9767
						if defined $::RD_TRACE;
9768
		push @item, $_tok;
9769
		$item{__ACTION1__}=$_tok;
9770
 
9771
 
9772
 
9773
		Parse::RecDescent::_trace(q{>>Matched production: [textmessage]<<},
9774
					  Parse::RecDescent::_tracefirst($text),
9775
					  q{part},
9776
					  $tracelevel)
9777
						if defined $::RD_TRACE;
9778
		$_matched = 1;
9779
		last;
9780
	}
9781
 
9782
		splice
9783
				@{$thisparser->{deferred}}, $def_at unless $_matched;
9784
 
9785
	while (!$_matched && !$commit)
9786
	{
9787
 
9788
		Parse::RecDescent::_trace(q{Trying production: [messagerfc822message]},
9789
					  Parse::RecDescent::_tracefirst($_[1]),
9790
					  q{part},
9791
					  $tracelevel)
9792
						if defined $::RD_TRACE;
9793
		my $thisprod = $thisrule->{"prods"}[2];
9794
		$text = $_[1];
9795
		my $_savetext;
9796
		@item = (q{part});
9797
		%item = (__RULE__ => q{part});
9798
		my $repcount = 0;
9799
 
9800
 
9801
		Parse::RecDescent::_trace(q{Trying subrule: [messagerfc822message]},
9802
				  Parse::RecDescent::_tracefirst($text),
9803
				  q{part},
9804
				  $tracelevel)
9805
					if defined $::RD_TRACE;
9806
		if (1) { no strict qw{refs};
9807
		$expectation->is(q{})->at($text);
9808
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::messagerfc822message($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
9809
		{
9810
 
9811
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [messagerfc822message]>>},
9812
						  Parse::RecDescent::_tracefirst($text),
9813
						  q{part},
9814
						  $tracelevel)
9815
							if defined $::RD_TRACE;
9816
			$expectation->failed();
9817
			last;
9818
		}
9819
		Parse::RecDescent::_trace(q{>>Matched subrule: [messagerfc822message]<< (return value: [}
9820
					. $_tok . q{]},
9821
 
9822
					  Parse::RecDescent::_tracefirst($text),
9823
					  q{part},
9824
					  $tracelevel)
9825
						if defined $::RD_TRACE;
9826
		$item{q{messagerfc822message}} = $_tok;
9827
		push @item, $_tok;
9828
 
9829
		}
9830
 
9831
		Parse::RecDescent::_trace(q{Trying action},
9832
					  Parse::RecDescent::_tracefirst($text),
9833
					  q{part},
9834
					  $tracelevel)
9835
						if defined $::RD_TRACE;
9836
 
9837
 
9838
		$_tok = ($_noactions) ? 0 : do {
9839
		$return = bless $item{messagerfc822message}, "Mail::IMAPClient::BodyStructure";
9840
		$return||defined($return);
9841
	};
9842
		unless (defined $_tok)
9843
		{
9844
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
9845
					if defined $::RD_TRACE;
9846
			last;
9847
		}
9848
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
9849
					  . $_tok . q{])},
9850
					  Parse::RecDescent::_tracefirst($text))
9851
						if defined $::RD_TRACE;
9852
		push @item, $_tok;
9853
		$item{__ACTION1__}=$_tok;
9854
 
9855
 
9856
 
9857
		Parse::RecDescent::_trace(q{>>Matched production: [messagerfc822message]<<},
9858
					  Parse::RecDescent::_tracefirst($text),
9859
					  q{part},
9860
					  $tracelevel)
9861
						if defined $::RD_TRACE;
9862
		$_matched = 1;
9863
		last;
9864
	}
9865
 
9866
		splice
9867
				@{$thisparser->{deferred}}, $def_at unless $_matched;
9868
 
9869
	while (!$_matched && !$commit)
9870
	{
9871
 
9872
		Parse::RecDescent::_trace(q{Trying production: [othertypemessage]},
9873
					  Parse::RecDescent::_tracefirst($_[1]),
9874
					  q{part},
9875
					  $tracelevel)
9876
						if defined $::RD_TRACE;
9877
		my $thisprod = $thisrule->{"prods"}[3];
9878
		$text = $_[1];
9879
		my $_savetext;
9880
		@item = (q{part});
9881
		%item = (__RULE__ => q{part});
9882
		my $repcount = 0;
9883
 
9884
 
9885
		Parse::RecDescent::_trace(q{Trying subrule: [othertypemessage]},
9886
				  Parse::RecDescent::_tracefirst($text),
9887
				  q{part},
9888
				  $tracelevel)
9889
					if defined $::RD_TRACE;
9890
		if (1) { no strict qw{refs};
9891
		$expectation->is(q{})->at($text);
9892
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::othertypemessage($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
9893
		{
9894
 
9895
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [othertypemessage]>>},
9896
						  Parse::RecDescent::_tracefirst($text),
9897
						  q{part},
9898
						  $tracelevel)
9899
							if defined $::RD_TRACE;
9900
			$expectation->failed();
9901
			last;
9902
		}
9903
		Parse::RecDescent::_trace(q{>>Matched subrule: [othertypemessage]<< (return value: [}
9904
					. $_tok . q{]},
9905
 
9906
					  Parse::RecDescent::_tracefirst($text),
9907
					  q{part},
9908
					  $tracelevel)
9909
						if defined $::RD_TRACE;
9910
		$item{q{othertypemessage}} = $_tok;
9911
		push @item, $_tok;
9912
 
9913
		}
9914
 
9915
		Parse::RecDescent::_trace(q{Trying action},
9916
					  Parse::RecDescent::_tracefirst($text),
9917
					  q{part},
9918
					  $tracelevel)
9919
						if defined $::RD_TRACE;
9920
 
9921
 
9922
		$_tok = ($_noactions) ? 0 : do {
9923
		$return = bless $item{othertypemessage}, "Mail::IMAPClient::BodyStructure";
9924
		$return||defined($return);
9925
	};
9926
		unless (defined $_tok)
9927
		{
9928
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
9929
					if defined $::RD_TRACE;
9930
			last;
9931
		}
9932
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
9933
					  . $_tok . q{])},
9934
					  Parse::RecDescent::_tracefirst($text))
9935
						if defined $::RD_TRACE;
9936
		push @item, $_tok;
9937
		$item{__ACTION1__}=$_tok;
9938
 
9939
 
9940
 
9941
		Parse::RecDescent::_trace(q{>>Matched production: [othertypemessage]<<},
9942
					  Parse::RecDescent::_tracefirst($text),
9943
					  q{part},
9944
					  $tracelevel)
9945
						if defined $::RD_TRACE;
9946
		$_matched = 1;
9947
		last;
9948
	}
9949
 
9950
		splice
9951
				@{$thisparser->{deferred}}, $def_at unless $_matched;
9952
 
9953
        unless ( $_matched || defined($score) )
9954
	{
9955
				splice @{$thisparser->{deferred}}, $def_at;
9956
 
9957
 
9958
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
9959
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
9960
					 Parse::RecDescent::_tracefirst($_[1]),
9961
					 q{part},
9962
					 $tracelevel)
9963
					if defined $::RD_TRACE;
9964
		return undef;
9965
	}
9966
	if (!defined($return) && defined($score))
9967
	{
9968
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
9969
					  q{part},
9970
					  $tracelevel)
9971
						if defined $::RD_TRACE;
9972
		$return = $score_return;
9973
	}
9974
	splice @{$thisparser->{errors}}, $err_at;
9975
	$return = $item[$#item] unless defined $return;
9976
	if (defined $::RD_TRACE)
9977
	{
9978
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
9979
					  $return . q{])}, "",
9980
					  q{part},
9981
					  $tracelevel);
9982
		Parse::RecDescent::_trace(q{(consumed: [} .
9983
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
9984
					  Parse::RecDescent::_tracefirst($text),
9985
					  , q{part},
9986
					  $tracelevel)
9987
	}
9988
	$_[1] = $text;
9989
	return $return;
9990
}
9991
 
9992
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
9993
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::SINGLE_QUOTED_STRING
9994
{
9995
	my $thisparser = $_[0];
9996
	use vars q{$tracelevel};
9997
	local $tracelevel = ($tracelevel||0)+1;
9998
	$ERRORS = 0;
9999
	my $thisrule = $thisparser->{"rules"}{"SINGLE_QUOTED_STRING"};
10000
 
10001
	Parse::RecDescent::_trace(q{Trying rule: [SINGLE_QUOTED_STRING]},
10002
				  Parse::RecDescent::_tracefirst($_[1]),
10003
				  q{SINGLE_QUOTED_STRING},
10004
				  $tracelevel)
10005
					if defined $::RD_TRACE;
10006
 
10007
	my $def_at = @{$thisparser->{deferred}};
10008
	my $err_at = @{$thisparser->{errors}};
10009
 
10010
	my $score;
10011
	my $score_return;
10012
	my $_tok;
10013
	my $return = undef;
10014
	my $_matched=0;
10015
	my $commit=0;
10016
	my @item = ();
10017
	my %item = ();
10018
	my $repeating =  defined($_[2]) && $_[2];
10019
	my $_noactions = defined($_[3]) && $_[3];
10020
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
10021
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
10022
	my $text;
10023
	my $lastsep="";
10024
    my $expectation = new Parse::RecDescent::Expectation(q{'''});
10025
	$expectation->at($_[1]);
10026
 
10027
	my $thisline;
10028
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
10029
 
10030
 
10031
 
10032
	while (!$_matched && !$commit)
10033
	{
10034
 
10035
		Parse::RecDescent::_trace(q{Trying production: [''' /(?:\\\\'|[^'])*/ ''']},
10036
					  Parse::RecDescent::_tracefirst($_[1]),
10037
					  q{SINGLE_QUOTED_STRING},
10038
					  $tracelevel)
10039
						if defined $::RD_TRACE;
10040
		my $thisprod = $thisrule->{"prods"}[0];
10041
		$text = $_[1];
10042
		my $_savetext;
10043
		@item = (q{SINGLE_QUOTED_STRING});
10044
		%item = (__RULE__ => q{SINGLE_QUOTED_STRING});
10045
		my $repcount = 0;
10046
 
10047
 
10048
		Parse::RecDescent::_trace(q{Trying terminal: [''']},
10049
					  Parse::RecDescent::_tracefirst($text),
10050
					  q{SINGLE_QUOTED_STRING},
10051
					  $tracelevel)
10052
						if defined $::RD_TRACE;
10053
		$lastsep = "";
10054
		$expectation->is(q{})->at($text);
10055
 
10056
 
10057
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "'"; 1 } and
10058
		     substr($text,0,length($_tok)) eq $_tok and
10059
		     do { substr($text,0,length($_tok)) = ""; 1; }
10060
		)
10061
		{
10062
 
10063
			$expectation->failed();
10064
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
10065
						  Parse::RecDescent::_tracefirst($text))
10066
							if defined $::RD_TRACE;
10067
			last;
10068
		}
10069
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
10070
						. $_tok . q{])},
10071
						  Parse::RecDescent::_tracefirst($text))
10072
							if defined $::RD_TRACE;
10073
		push @item, $item{__STRING1__}=$_tok;
10074
 
10075
 
10076
		Parse::RecDescent::_trace(q{Trying terminal: [/(?:\\\\'|[^'])*/]}, Parse::RecDescent::_tracefirst($text),
10077
					  q{SINGLE_QUOTED_STRING},
10078
					  $tracelevel)
10079
						if defined $::RD_TRACE;
10080
		$lastsep = "";
10081
		$expectation->is(q{/(?:\\\\'|[^'])*/})->at($text);
10082
 
10083
 
10084
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:(?:\\'|[^'])*)//)
10085
		{
10086
 
10087
			$expectation->failed();
10088
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
10089
						  Parse::RecDescent::_tracefirst($text))
10090
					if defined $::RD_TRACE;
10091
 
10092
			last;
10093
		}
10094
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
10095
						. $& . q{])},
10096
						  Parse::RecDescent::_tracefirst($text))
10097
					if defined $::RD_TRACE;
10098
		push @item, $item{__PATTERN1__}=$&;
10099
 
10100
 
10101
		Parse::RecDescent::_trace(q{Trying terminal: [''']},
10102
					  Parse::RecDescent::_tracefirst($text),
10103
					  q{SINGLE_QUOTED_STRING},
10104
					  $tracelevel)
10105
						if defined $::RD_TRACE;
10106
		$lastsep = "";
10107
		$expectation->is(q{'''})->at($text);
10108
 
10109
 
10110
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "'"; 1 } and
10111
		     substr($text,0,length($_tok)) eq $_tok and
10112
		     do { substr($text,0,length($_tok)) = ""; 1; }
10113
		)
10114
		{
10115
 
10116
			$expectation->failed();
10117
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
10118
						  Parse::RecDescent::_tracefirst($text))
10119
							if defined $::RD_TRACE;
10120
			last;
10121
		}
10122
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
10123
						. $_tok . q{])},
10124
						  Parse::RecDescent::_tracefirst($text))
10125
							if defined $::RD_TRACE;
10126
		push @item, $item{__STRING2__}=$_tok;
10127
 
10128
 
10129
		Parse::RecDescent::_trace(q{Trying action},
10130
					  Parse::RecDescent::_tracefirst($text),
10131
					  q{SINGLE_QUOTED_STRING},
10132
					  $tracelevel)
10133
						if defined $::RD_TRACE;
10134
 
10135
 
10136
		$_tok = ($_noactions) ? 0 : do {
10137
 
10138
	$return = $item{__PATTERN1__} ;
10139
	$return||defined($return);
10140
};
10141
		unless (defined $_tok)
10142
		{
10143
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
10144
					if defined $::RD_TRACE;
10145
			last;
10146
		}
10147
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
10148
					  . $_tok . q{])},
10149
					  Parse::RecDescent::_tracefirst($text))
10150
						if defined $::RD_TRACE;
10151
		push @item, $_tok;
10152
		$item{__ACTION1__}=$_tok;
10153
 
10154
 
10155
 
10156
		Parse::RecDescent::_trace(q{>>Matched production: [''' /(?:\\\\'|[^'])*/ ''']<<},
10157
					  Parse::RecDescent::_tracefirst($text),
10158
					  q{SINGLE_QUOTED_STRING},
10159
					  $tracelevel)
10160
						if defined $::RD_TRACE;
10161
		$_matched = 1;
10162
		last;
10163
	}
10164
 
10165
		splice
10166
				@{$thisparser->{deferred}}, $def_at unless $_matched;
10167
 
10168
        unless ( $_matched || defined($score) )
10169
	{
10170
				splice @{$thisparser->{deferred}}, $def_at;
10171
 
10172
 
10173
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
10174
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
10175
					 Parse::RecDescent::_tracefirst($_[1]),
10176
					 q{SINGLE_QUOTED_STRING},
10177
					 $tracelevel)
10178
					if defined $::RD_TRACE;
10179
		return undef;
10180
	}
10181
	if (!defined($return) && defined($score))
10182
	{
10183
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
10184
					  q{SINGLE_QUOTED_STRING},
10185
					  $tracelevel)
10186
						if defined $::RD_TRACE;
10187
		$return = $score_return;
10188
	}
10189
	splice @{$thisparser->{errors}}, $err_at;
10190
	$return = $item[$#item] unless defined $return;
10191
	if (defined $::RD_TRACE)
10192
	{
10193
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
10194
					  $return . q{])}, "",
10195
					  q{SINGLE_QUOTED_STRING},
10196
					  $tracelevel);
10197
		Parse::RecDescent::_trace(q{(consumed: [} .
10198
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
10199
					  Parse::RecDescent::_tracefirst($text),
10200
					  , q{SINGLE_QUOTED_STRING},
10201
					  $tracelevel)
10202
	}
10203
	$_[1] = $text;
10204
	return $return;
10205
}
10206
 
10207
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
10208
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bcc
10209
{
10210
	my $thisparser = $_[0];
10211
	use vars q{$tracelevel};
10212
	local $tracelevel = ($tracelevel||0)+1;
10213
	$ERRORS = 0;
10214
	my $thisrule = $thisparser->{"rules"}{"bcc"};
10215
 
10216
	Parse::RecDescent::_trace(q{Trying rule: [bcc]},
10217
				  Parse::RecDescent::_tracefirst($_[1]),
10218
				  q{bcc},
10219
				  $tracelevel)
10220
					if defined $::RD_TRACE;
10221
 
10222
	my $def_at = @{$thisparser->{deferred}};
10223
	my $err_at = @{$thisparser->{errors}};
10224
 
10225
	my $score;
10226
	my $score_return;
10227
	my $_tok;
10228
	my $return = undef;
10229
	my $_matched=0;
10230
	my $commit=0;
10231
	my @item = ();
10232
	my %item = ();
10233
	my $repeating =  defined($_[2]) && $_[2];
10234
	my $_noactions = defined($_[3]) && $_[3];
10235
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
10236
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
10237
	my $text;
10238
	my $lastsep="";
10239
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or '('});
10240
	$expectation->at($_[1]);
10241
 
10242
	my $thisline;
10243
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
10244
 
10245
 
10246
 
10247
	while (!$_matched && !$commit)
10248
	{
10249
 
10250
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
10251
					  Parse::RecDescent::_tracefirst($_[1]),
10252
					  q{bcc},
10253
					  $tracelevel)
10254
						if defined $::RD_TRACE;
10255
		my $thisprod = $thisrule->{"prods"}[0];
10256
		$text = $_[1];
10257
		my $_savetext;
10258
		@item = (q{bcc});
10259
		%item = (__RULE__ => q{bcc});
10260
		my $repcount = 0;
10261
 
10262
 
10263
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
10264
				  Parse::RecDescent::_tracefirst($text),
10265
				  q{bcc},
10266
				  $tracelevel)
10267
					if defined $::RD_TRACE;
10268
		if (1) { no strict qw{refs};
10269
		$expectation->is(q{})->at($text);
10270
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
10271
		{
10272
 
10273
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
10274
						  Parse::RecDescent::_tracefirst($text),
10275
						  q{bcc},
10276
						  $tracelevel)
10277
							if defined $::RD_TRACE;
10278
			$expectation->failed();
10279
			last;
10280
		}
10281
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
10282
					. $_tok . q{]},
10283
 
10284
					  Parse::RecDescent::_tracefirst($text),
10285
					  q{bcc},
10286
					  $tracelevel)
10287
						if defined $::RD_TRACE;
10288
		$item{q{NIL}} = $_tok;
10289
		push @item, $_tok;
10290
 
10291
		}
10292
 
10293
 
10294
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
10295
					  Parse::RecDescent::_tracefirst($text),
10296
					  q{bcc},
10297
					  $tracelevel)
10298
						if defined $::RD_TRACE;
10299
		$_matched = 1;
10300
		last;
10301
	}
10302
 
10303
		splice
10304
				@{$thisparser->{deferred}}, $def_at unless $_matched;
10305
 
10306
	while (!$_matched && !$commit)
10307
	{
10308
 
10309
		Parse::RecDescent::_trace(q{Trying production: ['(' addressstruct ')']},
10310
					  Parse::RecDescent::_tracefirst($_[1]),
10311
					  q{bcc},
10312
					  $tracelevel)
10313
						if defined $::RD_TRACE;
10314
		my $thisprod = $thisrule->{"prods"}[1];
10315
		$text = $_[1];
10316
		my $_savetext;
10317
		@item = (q{bcc});
10318
		%item = (__RULE__ => q{bcc});
10319
		my $repcount = 0;
10320
 
10321
 
10322
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
10323
					  Parse::RecDescent::_tracefirst($text),
10324
					  q{bcc},
10325
					  $tracelevel)
10326
						if defined $::RD_TRACE;
10327
		$lastsep = "";
10328
		$expectation->is(q{})->at($text);
10329
 
10330
 
10331
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "("; 1 } and
10332
		     substr($text,0,length($_tok)) eq $_tok and
10333
		     do { substr($text,0,length($_tok)) = ""; 1; }
10334
		)
10335
		{
10336
 
10337
			$expectation->failed();
10338
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
10339
						  Parse::RecDescent::_tracefirst($text))
10340
							if defined $::RD_TRACE;
10341
			last;
10342
		}
10343
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
10344
						. $_tok . q{])},
10345
						  Parse::RecDescent::_tracefirst($text))
10346
							if defined $::RD_TRACE;
10347
		push @item, $item{__STRING1__}=$_tok;
10348
 
10349
 
10350
		Parse::RecDescent::_trace(q{Trying repeated subrule: [addressstruct]},
10351
				  Parse::RecDescent::_tracefirst($text),
10352
				  q{bcc},
10353
				  $tracelevel)
10354
					if defined $::RD_TRACE;
10355
		$expectation->is(q{addressstruct})->at($text);
10356
 
10357
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::addressstruct, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
10358
		{
10359
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [addressstruct]>>},
10360
						  Parse::RecDescent::_tracefirst($text),
10361
						  q{bcc},
10362
						  $tracelevel)
10363
							if defined $::RD_TRACE;
10364
			last;
10365
		}
10366
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [addressstruct]<< (}
10367
					. @$_tok . q{ times)},
10368
 
10369
					  Parse::RecDescent::_tracefirst($text),
10370
					  q{bcc},
10371
					  $tracelevel)
10372
						if defined $::RD_TRACE;
10373
		$item{q{addressstruct(s)}} = $_tok;
10374
		push @item, $_tok;
10375
 
10376
 
10377
 
10378
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
10379
					  Parse::RecDescent::_tracefirst($text),
10380
					  q{bcc},
10381
					  $tracelevel)
10382
						if defined $::RD_TRACE;
10383
		$lastsep = "";
10384
		$expectation->is(q{')'})->at($text);
10385
 
10386
 
10387
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
10388
		     substr($text,0,length($_tok)) eq $_tok and
10389
		     do { substr($text,0,length($_tok)) = ""; 1; }
10390
		)
10391
		{
10392
 
10393
			$expectation->failed();
10394
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
10395
						  Parse::RecDescent::_tracefirst($text))
10396
							if defined $::RD_TRACE;
10397
			last;
10398
		}
10399
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
10400
						. $_tok . q{])},
10401
						  Parse::RecDescent::_tracefirst($text))
10402
							if defined $::RD_TRACE;
10403
		push @item, $item{__STRING2__}=$_tok;
10404
 
10405
 
10406
		Parse::RecDescent::_trace(q{Trying action},
10407
					  Parse::RecDescent::_tracefirst($text),
10408
					  q{bcc},
10409
					  $tracelevel)
10410
						if defined $::RD_TRACE;
10411
 
10412
 
10413
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{'addressstruct(s)'} };
10414
		unless (defined $_tok)
10415
		{
10416
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
10417
					if defined $::RD_TRACE;
10418
			last;
10419
		}
10420
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
10421
					  . $_tok . q{])},
10422
					  Parse::RecDescent::_tracefirst($text))
10423
						if defined $::RD_TRACE;
10424
		push @item, $_tok;
10425
		$item{__ACTION1__}=$_tok;
10426
 
10427
 
10428
 
10429
		Parse::RecDescent::_trace(q{>>Matched production: ['(' addressstruct ')']<<},
10430
					  Parse::RecDescent::_tracefirst($text),
10431
					  q{bcc},
10432
					  $tracelevel)
10433
						if defined $::RD_TRACE;
10434
		$_matched = 1;
10435
		last;
10436
	}
10437
 
10438
		splice
10439
				@{$thisparser->{deferred}}, $def_at unless $_matched;
10440
 
10441
        unless ( $_matched || defined($score) )
10442
	{
10443
				splice @{$thisparser->{deferred}}, $def_at;
10444
 
10445
 
10446
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
10447
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
10448
					 Parse::RecDescent::_tracefirst($_[1]),
10449
					 q{bcc},
10450
					 $tracelevel)
10451
					if defined $::RD_TRACE;
10452
		return undef;
10453
	}
10454
	if (!defined($return) && defined($score))
10455
	{
10456
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
10457
					  q{bcc},
10458
					  $tracelevel)
10459
						if defined $::RD_TRACE;
10460
		$return = $score_return;
10461
	}
10462
	splice @{$thisparser->{errors}}, $err_at;
10463
	$return = $item[$#item] unless defined $return;
10464
	if (defined $::RD_TRACE)
10465
	{
10466
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
10467
					  $return . q{])}, "",
10468
					  q{bcc},
10469
					  $tracelevel);
10470
		Parse::RecDescent::_trace(q{(consumed: [} .
10471
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
10472
					  Parse::RecDescent::_tracefirst($text),
10473
					  , q{bcc},
10474
					  $tracelevel)
10475
	}
10476
	$_[1] = $text;
10477
	return $return;
10478
}
10479
 
10480
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
10481
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::rfc822message
10482
{
10483
	my $thisparser = $_[0];
10484
	use vars q{$tracelevel};
10485
	local $tracelevel = ($tracelevel||0)+1;
10486
	$ERRORS = 0;
10487
	my $thisrule = $thisparser->{"rules"}{"rfc822message"};
10488
 
10489
	Parse::RecDescent::_trace(q{Trying rule: [rfc822message]},
10490
				  Parse::RecDescent::_tracefirst($_[1]),
10491
				  q{rfc822message},
10492
				  $tracelevel)
10493
					if defined $::RD_TRACE;
10494
 
10495
	my $def_at = @{$thisparser->{deferred}};
10496
	my $err_at = @{$thisparser->{errors}};
10497
 
10498
	my $score;
10499
	my $score_return;
10500
	my $_tok;
10501
	my $return = undef;
10502
	my $_matched=0;
10503
	my $commit=0;
10504
	my @item = ();
10505
	my %item = ();
10506
	my $repeating =  defined($_[2]) && $_[2];
10507
	my $_noactions = defined($_[3]) && $_[3];
10508
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
10509
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
10510
	my $text;
10511
	my $lastsep="";
10512
    my $expectation = new Parse::RecDescent::Expectation(q{MESSAGE});
10513
	$expectation->at($_[1]);
10514
 
10515
	my $thisline;
10516
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
10517
 
10518
 
10519
 
10520
	while (!$_matched && !$commit)
10521
	{
10522
 
10523
		Parse::RecDescent::_trace(q{Trying production: [MESSAGE RFC822]},
10524
					  Parse::RecDescent::_tracefirst($_[1]),
10525
					  q{rfc822message},
10526
					  $tracelevel)
10527
						if defined $::RD_TRACE;
10528
		my $thisprod = $thisrule->{"prods"}[0];
10529
		$text = $_[1];
10530
		my $_savetext;
10531
		@item = (q{rfc822message});
10532
		%item = (__RULE__ => q{rfc822message});
10533
		my $repcount = 0;
10534
 
10535
 
10536
		Parse::RecDescent::_trace(q{Trying subrule: [MESSAGE]},
10537
				  Parse::RecDescent::_tracefirst($text),
10538
				  q{rfc822message},
10539
				  $tracelevel)
10540
					if defined $::RD_TRACE;
10541
		if (1) { no strict qw{refs};
10542
		$expectation->is(q{})->at($text);
10543
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::MESSAGE($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
10544
		{
10545
 
10546
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [MESSAGE]>>},
10547
						  Parse::RecDescent::_tracefirst($text),
10548
						  q{rfc822message},
10549
						  $tracelevel)
10550
							if defined $::RD_TRACE;
10551
			$expectation->failed();
10552
			last;
10553
		}
10554
		Parse::RecDescent::_trace(q{>>Matched subrule: [MESSAGE]<< (return value: [}
10555
					. $_tok . q{]},
10556
 
10557
					  Parse::RecDescent::_tracefirst($text),
10558
					  q{rfc822message},
10559
					  $tracelevel)
10560
						if defined $::RD_TRACE;
10561
		$item{q{MESSAGE}} = $_tok;
10562
		push @item, $_tok;
10563
 
10564
		}
10565
 
10566
		Parse::RecDescent::_trace(q{Trying subrule: [RFC822]},
10567
				  Parse::RecDescent::_tracefirst($text),
10568
				  q{rfc822message},
10569
				  $tracelevel)
10570
					if defined $::RD_TRACE;
10571
		if (1) { no strict qw{refs};
10572
		$expectation->is(q{RFC822})->at($text);
10573
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::RFC822($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
10574
		{
10575
 
10576
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [RFC822]>>},
10577
						  Parse::RecDescent::_tracefirst($text),
10578
						  q{rfc822message},
10579
						  $tracelevel)
10580
							if defined $::RD_TRACE;
10581
			$expectation->failed();
10582
			last;
10583
		}
10584
		Parse::RecDescent::_trace(q{>>Matched subrule: [RFC822]<< (return value: [}
10585
					. $_tok . q{]},
10586
 
10587
					  Parse::RecDescent::_tracefirst($text),
10588
					  q{rfc822message},
10589
					  $tracelevel)
10590
						if defined $::RD_TRACE;
10591
		$item{q{RFC822}} = $_tok;
10592
		push @item, $_tok;
10593
 
10594
		}
10595
 
10596
		Parse::RecDescent::_trace(q{Trying action},
10597
					  Parse::RecDescent::_tracefirst($text),
10598
					  q{rfc822message},
10599
					  $tracelevel)
10600
						if defined $::RD_TRACE;
10601
 
10602
 
10603
		$_tok = ($_noactions) ? 0 : do { $return = "MESSAGE RFC822" };
10604
		unless (defined $_tok)
10605
		{
10606
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
10607
					if defined $::RD_TRACE;
10608
			last;
10609
		}
10610
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
10611
					  . $_tok . q{])},
10612
					  Parse::RecDescent::_tracefirst($text))
10613
						if defined $::RD_TRACE;
10614
		push @item, $_tok;
10615
		$item{__ACTION1__}=$_tok;
10616
 
10617
 
10618
 
10619
		Parse::RecDescent::_trace(q{>>Matched production: [MESSAGE RFC822]<<},
10620
					  Parse::RecDescent::_tracefirst($text),
10621
					  q{rfc822message},
10622
					  $tracelevel)
10623
						if defined $::RD_TRACE;
10624
		$_matched = 1;
10625
		last;
10626
	}
10627
 
10628
		splice
10629
				@{$thisparser->{deferred}}, $def_at unless $_matched;
10630
 
10631
        unless ( $_matched || defined($score) )
10632
	{
10633
				splice @{$thisparser->{deferred}}, $def_at;
10634
 
10635
 
10636
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
10637
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
10638
					 Parse::RecDescent::_tracefirst($_[1]),
10639
					 q{rfc822message},
10640
					 $tracelevel)
10641
					if defined $::RD_TRACE;
10642
		return undef;
10643
	}
10644
	if (!defined($return) && defined($score))
10645
	{
10646
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
10647
					  q{rfc822message},
10648
					  $tracelevel)
10649
						if defined $::RD_TRACE;
10650
		$return = $score_return;
10651
	}
10652
	splice @{$thisparser->{errors}}, $err_at;
10653
	$return = $item[$#item] unless defined $return;
10654
	if (defined $::RD_TRACE)
10655
	{
10656
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
10657
					  $return . q{])}, "",
10658
					  q{rfc822message},
10659
					  $tracelevel);
10660
		Parse::RecDescent::_trace(q{(consumed: [} .
10661
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
10662
					  Parse::RecDescent::_tracefirst($text),
10663
					  , q{rfc822message},
10664
					  $tracelevel)
10665
	}
10666
	$_[1] = $text;
10667
	return $return;
10668
}
10669
 
10670
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
10671
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::OLDSTRING
10672
{
10673
	my $thisparser = $_[0];
10674
	use vars q{$tracelevel};
10675
	local $tracelevel = ($tracelevel||0)+1;
10676
	$ERRORS = 0;
10677
	my $thisrule = $thisparser->{"rules"}{"OLDSTRING"};
10678
 
10679
	Parse::RecDescent::_trace(q{Trying rule: [OLDSTRING]},
10680
				  Parse::RecDescent::_tracefirst($_[1]),
10681
				  q{OLDSTRING},
10682
				  $tracelevel)
10683
					if defined $::RD_TRACE;
10684
 
10685
	my $def_at = @{$thisparser->{deferred}};
10686
	my $err_at = @{$thisparser->{errors}};
10687
 
10688
	my $score;
10689
	my $score_return;
10690
	my $_tok;
10691
	my $return = undef;
10692
	my $_matched=0;
10693
	my $commit=0;
10694
	my @item = ();
10695
	my %item = ();
10696
	my $repeating =  defined($_[2]) && $_[2];
10697
	my $_noactions = defined($_[3]) && $_[3];
10698
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
10699
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
10700
	my $text;
10701
	my $lastsep="";
10702
    my $expectation = new Parse::RecDescent::Expectation(q{/^"((?:[^"\\\\]|\\\\.)*)"/, or /^([^ \\(\\)]+)/});
10703
	$expectation->at($_[1]);
10704
 
10705
	my $thisline;
10706
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
10707
 
10708
 
10709
 
10710
	while (!$_matched && !$commit)
10711
	{
10712
 
10713
		Parse::RecDescent::_trace(q{Trying production: [/^"((?:[^"\\\\]|\\\\.)*)"/]},
10714
					  Parse::RecDescent::_tracefirst($_[1]),
10715
					  q{OLDSTRING},
10716
					  $tracelevel)
10717
						if defined $::RD_TRACE;
10718
		my $thisprod = $thisrule->{"prods"}[0];
10719
		$text = $_[1];
10720
		my $_savetext;
10721
		@item = (q{OLDSTRING});
10722
		%item = (__RULE__ => q{OLDSTRING});
10723
		my $repcount = 0;
10724
 
10725
 
10726
		Parse::RecDescent::_trace(q{Trying terminal: [/^"((?:[^"\\\\]|\\\\.)*)"/]}, Parse::RecDescent::_tracefirst($text),
10727
					  q{OLDSTRING},
10728
					  $tracelevel)
10729
						if defined $::RD_TRACE;
10730
		$lastsep = "";
10731
		$expectation->is(q{})->at($text);
10732
 
10733
 
10734
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:^"((?:[^"\\]|\\.)*)")//)
10735
		{
10736
 
10737
			$expectation->failed();
10738
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
10739
						  Parse::RecDescent::_tracefirst($text))
10740
					if defined $::RD_TRACE;
10741
 
10742
			last;
10743
		}
10744
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
10745
						. $& . q{])},
10746
						  Parse::RecDescent::_tracefirst($text))
10747
					if defined $::RD_TRACE;
10748
		push @item, $item{__PATTERN1__}=$&;
10749
 
10750
 
10751
 
10752
		Parse::RecDescent::_trace(q{>>Matched production: [/^"((?:[^"\\\\]|\\\\.)*)"/]<<},
10753
					  Parse::RecDescent::_tracefirst($text),
10754
					  q{OLDSTRING},
10755
					  $tracelevel)
10756
						if defined $::RD_TRACE;
10757
		$_matched = 1;
10758
		last;
10759
	}
10760
 
10761
		splice
10762
				@{$thisparser->{deferred}}, $def_at unless $_matched;
10763
 
10764
	while (!$_matched && !$commit)
10765
	{
10766
 
10767
		Parse::RecDescent::_trace(q{Trying production: [/^([^ \\(\\)]+)/]},
10768
					  Parse::RecDescent::_tracefirst($_[1]),
10769
					  q{OLDSTRING},
10770
					  $tracelevel)
10771
						if defined $::RD_TRACE;
10772
		my $thisprod = $thisrule->{"prods"}[1];
10773
		$text = $_[1];
10774
		my $_savetext;
10775
		@item = (q{OLDSTRING});
10776
		%item = (__RULE__ => q{OLDSTRING});
10777
		my $repcount = 0;
10778
 
10779
 
10780
		Parse::RecDescent::_trace(q{Trying terminal: [/^([^ \\(\\)]+)/]}, Parse::RecDescent::_tracefirst($text),
10781
					  q{OLDSTRING},
10782
					  $tracelevel)
10783
						if defined $::RD_TRACE;
10784
		$lastsep = "";
10785
		$expectation->is(q{})->at($text);
10786
 
10787
 
10788
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:^([^ \(\)]+))//)
10789
		{
10790
 
10791
			$expectation->failed();
10792
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
10793
						  Parse::RecDescent::_tracefirst($text))
10794
					if defined $::RD_TRACE;
10795
 
10796
			last;
10797
		}
10798
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
10799
						. $& . q{])},
10800
						  Parse::RecDescent::_tracefirst($text))
10801
					if defined $::RD_TRACE;
10802
		push @item, $item{__PATTERN1__}=$&;
10803
 
10804
 
10805
		Parse::RecDescent::_trace(q{Trying action},
10806
					  Parse::RecDescent::_tracefirst($text),
10807
					  q{OLDSTRING},
10808
					  $tracelevel)
10809
						if defined $::RD_TRACE;
10810
 
10811
 
10812
		$_tok = ($_noactions) ? 0 : do {       $item{__PATTERN1__} =~ s/^"(.*)"$/$1/;
10813
                                $return = $item{__PATTERN1__} || $item{__PATTERN2__} ;
10814
                                $return||defined($return);
10815
                        };
10816
		unless (defined $_tok)
10817
		{
10818
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
10819
					if defined $::RD_TRACE;
10820
			last;
10821
		}
10822
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
10823
					  . $_tok . q{])},
10824
					  Parse::RecDescent::_tracefirst($text))
10825
						if defined $::RD_TRACE;
10826
		push @item, $_tok;
10827
		$item{__ACTION1__}=$_tok;
10828
 
10829
 
10830
 
10831
		Parse::RecDescent::_trace(q{>>Matched production: [/^([^ \\(\\)]+)/]<<},
10832
					  Parse::RecDescent::_tracefirst($text),
10833
					  q{OLDSTRING},
10834
					  $tracelevel)
10835
						if defined $::RD_TRACE;
10836
		$_matched = 1;
10837
		last;
10838
	}
10839
 
10840
		splice
10841
				@{$thisparser->{deferred}}, $def_at unless $_matched;
10842
 
10843
        unless ( $_matched || defined($score) )
10844
	{
10845
				splice @{$thisparser->{deferred}}, $def_at;
10846
 
10847
 
10848
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
10849
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
10850
					 Parse::RecDescent::_tracefirst($_[1]),
10851
					 q{OLDSTRING},
10852
					 $tracelevel)
10853
					if defined $::RD_TRACE;
10854
		return undef;
10855
	}
10856
	if (!defined($return) && defined($score))
10857
	{
10858
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
10859
					  q{OLDSTRING},
10860
					  $tracelevel)
10861
						if defined $::RD_TRACE;
10862
		$return = $score_return;
10863
	}
10864
	splice @{$thisparser->{errors}}, $err_at;
10865
	$return = $item[$#item] unless defined $return;
10866
	if (defined $::RD_TRACE)
10867
	{
10868
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
10869
					  $return . q{])}, "",
10870
					  q{OLDSTRING},
10871
					  $tracelevel);
10872
		Parse::RecDescent::_trace(q{(consumed: [} .
10873
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
10874
					  Parse::RecDescent::_tracefirst($text),
10875
					  , q{OLDSTRING},
10876
					  $tracelevel)
10877
	}
10878
	$_[1] = $text;
10879
	return $return;
10880
}
10881
 
10882
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
10883
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::addressstruct
10884
{
10885
	my $thisparser = $_[0];
10886
	use vars q{$tracelevel};
10887
	local $tracelevel = ($tracelevel||0)+1;
10888
	$ERRORS = 0;
10889
	my $thisrule = $thisparser->{"rules"}{"addressstruct"};
10890
 
10891
	Parse::RecDescent::_trace(q{Trying rule: [addressstruct]},
10892
				  Parse::RecDescent::_tracefirst($_[1]),
10893
				  q{addressstruct},
10894
				  $tracelevel)
10895
					if defined $::RD_TRACE;
10896
 
10897
	my $def_at = @{$thisparser->{deferred}};
10898
	my $err_at = @{$thisparser->{errors}};
10899
 
10900
	my $score;
10901
	my $score_return;
10902
	my $_tok;
10903
	my $return = undef;
10904
	my $_matched=0;
10905
	my $commit=0;
10906
	my @item = ();
10907
	my %item = ();
10908
	my $repeating =  defined($_[2]) && $_[2];
10909
	my $_noactions = defined($_[3]) && $_[3];
10910
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
10911
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
10912
	my $text;
10913
	my $lastsep="";
10914
    my $expectation = new Parse::RecDescent::Expectation(q{'('});
10915
	$expectation->at($_[1]);
10916
 
10917
	my $thisline;
10918
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
10919
 
10920
 
10921
 
10922
	while (!$_matched && !$commit)
10923
	{
10924
 
10925
		Parse::RecDescent::_trace(q{Trying production: ['(' personalname sourceroute mailboxname hostname ')']},
10926
					  Parse::RecDescent::_tracefirst($_[1]),
10927
					  q{addressstruct},
10928
					  $tracelevel)
10929
						if defined $::RD_TRACE;
10930
		my $thisprod = $thisrule->{"prods"}[0];
10931
		$text = $_[1];
10932
		my $_savetext;
10933
		@item = (q{addressstruct});
10934
		%item = (__RULE__ => q{addressstruct});
10935
		my $repcount = 0;
10936
 
10937
 
10938
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
10939
					  Parse::RecDescent::_tracefirst($text),
10940
					  q{addressstruct},
10941
					  $tracelevel)
10942
						if defined $::RD_TRACE;
10943
		$lastsep = "";
10944
		$expectation->is(q{})->at($text);
10945
 
10946
 
10947
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "("; 1 } and
10948
		     substr($text,0,length($_tok)) eq $_tok and
10949
		     do { substr($text,0,length($_tok)) = ""; 1; }
10950
		)
10951
		{
10952
 
10953
			$expectation->failed();
10954
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
10955
						  Parse::RecDescent::_tracefirst($text))
10956
							if defined $::RD_TRACE;
10957
			last;
10958
		}
10959
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
10960
						. $_tok . q{])},
10961
						  Parse::RecDescent::_tracefirst($text))
10962
							if defined $::RD_TRACE;
10963
		push @item, $item{__STRING1__}=$_tok;
10964
 
10965
 
10966
		Parse::RecDescent::_trace(q{Trying subrule: [personalname]},
10967
				  Parse::RecDescent::_tracefirst($text),
10968
				  q{addressstruct},
10969
				  $tracelevel)
10970
					if defined $::RD_TRACE;
10971
		if (1) { no strict qw{refs};
10972
		$expectation->is(q{personalname})->at($text);
10973
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::personalname($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
10974
		{
10975
 
10976
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [personalname]>>},
10977
						  Parse::RecDescent::_tracefirst($text),
10978
						  q{addressstruct},
10979
						  $tracelevel)
10980
							if defined $::RD_TRACE;
10981
			$expectation->failed();
10982
			last;
10983
		}
10984
		Parse::RecDescent::_trace(q{>>Matched subrule: [personalname]<< (return value: [}
10985
					. $_tok . q{]},
10986
 
10987
					  Parse::RecDescent::_tracefirst($text),
10988
					  q{addressstruct},
10989
					  $tracelevel)
10990
						if defined $::RD_TRACE;
10991
		$item{q{personalname}} = $_tok;
10992
		push @item, $_tok;
10993
 
10994
		}
10995
 
10996
		Parse::RecDescent::_trace(q{Trying subrule: [sourceroute]},
10997
				  Parse::RecDescent::_tracefirst($text),
10998
				  q{addressstruct},
10999
				  $tracelevel)
11000
					if defined $::RD_TRACE;
11001
		if (1) { no strict qw{refs};
11002
		$expectation->is(q{sourceroute})->at($text);
11003
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::sourceroute($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
11004
		{
11005
 
11006
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [sourceroute]>>},
11007
						  Parse::RecDescent::_tracefirst($text),
11008
						  q{addressstruct},
11009
						  $tracelevel)
11010
							if defined $::RD_TRACE;
11011
			$expectation->failed();
11012
			last;
11013
		}
11014
		Parse::RecDescent::_trace(q{>>Matched subrule: [sourceroute]<< (return value: [}
11015
					. $_tok . q{]},
11016
 
11017
					  Parse::RecDescent::_tracefirst($text),
11018
					  q{addressstruct},
11019
					  $tracelevel)
11020
						if defined $::RD_TRACE;
11021
		$item{q{sourceroute}} = $_tok;
11022
		push @item, $_tok;
11023
 
11024
		}
11025
 
11026
		Parse::RecDescent::_trace(q{Trying subrule: [mailboxname]},
11027
				  Parse::RecDescent::_tracefirst($text),
11028
				  q{addressstruct},
11029
				  $tracelevel)
11030
					if defined $::RD_TRACE;
11031
		if (1) { no strict qw{refs};
11032
		$expectation->is(q{mailboxname})->at($text);
11033
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::mailboxname($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
11034
		{
11035
 
11036
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [mailboxname]>>},
11037
						  Parse::RecDescent::_tracefirst($text),
11038
						  q{addressstruct},
11039
						  $tracelevel)
11040
							if defined $::RD_TRACE;
11041
			$expectation->failed();
11042
			last;
11043
		}
11044
		Parse::RecDescent::_trace(q{>>Matched subrule: [mailboxname]<< (return value: [}
11045
					. $_tok . q{]},
11046
 
11047
					  Parse::RecDescent::_tracefirst($text),
11048
					  q{addressstruct},
11049
					  $tracelevel)
11050
						if defined $::RD_TRACE;
11051
		$item{q{mailboxname}} = $_tok;
11052
		push @item, $_tok;
11053
 
11054
		}
11055
 
11056
		Parse::RecDescent::_trace(q{Trying subrule: [hostname]},
11057
				  Parse::RecDescent::_tracefirst($text),
11058
				  q{addressstruct},
11059
				  $tracelevel)
11060
					if defined $::RD_TRACE;
11061
		if (1) { no strict qw{refs};
11062
		$expectation->is(q{hostname})->at($text);
11063
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::hostname($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
11064
		{
11065
 
11066
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [hostname]>>},
11067
						  Parse::RecDescent::_tracefirst($text),
11068
						  q{addressstruct},
11069
						  $tracelevel)
11070
							if defined $::RD_TRACE;
11071
			$expectation->failed();
11072
			last;
11073
		}
11074
		Parse::RecDescent::_trace(q{>>Matched subrule: [hostname]<< (return value: [}
11075
					. $_tok . q{]},
11076
 
11077
					  Parse::RecDescent::_tracefirst($text),
11078
					  q{addressstruct},
11079
					  $tracelevel)
11080
						if defined $::RD_TRACE;
11081
		$item{q{hostname}} = $_tok;
11082
		push @item, $_tok;
11083
 
11084
		}
11085
 
11086
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
11087
					  Parse::RecDescent::_tracefirst($text),
11088
					  q{addressstruct},
11089
					  $tracelevel)
11090
						if defined $::RD_TRACE;
11091
		$lastsep = "";
11092
		$expectation->is(q{')'})->at($text);
11093
 
11094
 
11095
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
11096
		     substr($text,0,length($_tok)) eq $_tok and
11097
		     do { substr($text,0,length($_tok)) = ""; 1; }
11098
		)
11099
		{
11100
 
11101
			$expectation->failed();
11102
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
11103
						  Parse::RecDescent::_tracefirst($text))
11104
							if defined $::RD_TRACE;
11105
			last;
11106
		}
11107
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
11108
						. $_tok . q{])},
11109
						  Parse::RecDescent::_tracefirst($text))
11110
							if defined $::RD_TRACE;
11111
		push @item, $item{__STRING2__}=$_tok;
11112
 
11113
 
11114
		Parse::RecDescent::_trace(q{Trying action},
11115
					  Parse::RecDescent::_tracefirst($text),
11116
					  q{addressstruct},
11117
					  $tracelevel)
11118
						if defined $::RD_TRACE;
11119
 
11120
 
11121
		$_tok = ($_noactions) ? 0 : do { $return = {
11122
			personalname => $item{personalname} ,	
11123
			sourceroute  => $item{sourceroute} ,	
11124
			mailboxname  => $item{mailboxname} ,	
11125
			hostname     => $item{hostname} ,	
11126
		  } ;
11127
		  bless($return, "Mail::IMAPClient::BodyStructure::Address");
11128
		};
11129
		unless (defined $_tok)
11130
		{
11131
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
11132
					if defined $::RD_TRACE;
11133
			last;
11134
		}
11135
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
11136
					  . $_tok . q{])},
11137
					  Parse::RecDescent::_tracefirst($text))
11138
						if defined $::RD_TRACE;
11139
		push @item, $_tok;
11140
		$item{__ACTION1__}=$_tok;
11141
 
11142
 
11143
 
11144
		Parse::RecDescent::_trace(q{>>Matched production: ['(' personalname sourceroute mailboxname hostname ')']<<},
11145
					  Parse::RecDescent::_tracefirst($text),
11146
					  q{addressstruct},
11147
					  $tracelevel)
11148
						if defined $::RD_TRACE;
11149
		$_matched = 1;
11150
		last;
11151
	}
11152
 
11153
		splice
11154
				@{$thisparser->{deferred}}, $def_at unless $_matched;
11155
 
11156
        unless ( $_matched || defined($score) )
11157
	{
11158
				splice @{$thisparser->{deferred}}, $def_at;
11159
 
11160
 
11161
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
11162
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
11163
					 Parse::RecDescent::_tracefirst($_[1]),
11164
					 q{addressstruct},
11165
					 $tracelevel)
11166
					if defined $::RD_TRACE;
11167
		return undef;
11168
	}
11169
	if (!defined($return) && defined($score))
11170
	{
11171
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
11172
					  q{addressstruct},
11173
					  $tracelevel)
11174
						if defined $::RD_TRACE;
11175
		$return = $score_return;
11176
	}
11177
	splice @{$thisparser->{errors}}, $err_at;
11178
	$return = $item[$#item] unless defined $return;
11179
	if (defined $::RD_TRACE)
11180
	{
11181
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
11182
					  $return . q{])}, "",
11183
					  q{addressstruct},
11184
					  $tracelevel);
11185
		Parse::RecDescent::_trace(q{(consumed: [} .
11186
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
11187
					  Parse::RecDescent::_tracefirst($text),
11188
					  , q{addressstruct},
11189
					  $tracelevel)
11190
	}
11191
	$_[1] = $text;
11192
	return $return;
11193
}
11194
 
11195
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
11196
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::sourceroute
11197
{
11198
	my $thisparser = $_[0];
11199
	use vars q{$tracelevel};
11200
	local $tracelevel = ($tracelevel||0)+1;
11201
	$ERRORS = 0;
11202
	my $thisrule = $thisparser->{"rules"}{"sourceroute"};
11203
 
11204
	Parse::RecDescent::_trace(q{Trying rule: [sourceroute]},
11205
				  Parse::RecDescent::_tracefirst($_[1]),
11206
				  q{sourceroute},
11207
				  $tracelevel)
11208
					if defined $::RD_TRACE;
11209
 
11210
	my $def_at = @{$thisparser->{deferred}};
11211
	my $err_at = @{$thisparser->{errors}};
11212
 
11213
	my $score;
11214
	my $score_return;
11215
	my $_tok;
11216
	my $return = undef;
11217
	my $_matched=0;
11218
	my $commit=0;
11219
	my @item = ();
11220
	my %item = ();
11221
	my $repeating =  defined($_[2]) && $_[2];
11222
	my $_noactions = defined($_[3]) && $_[3];
11223
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
11224
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
11225
	my $text;
11226
	my $lastsep="";
11227
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or STRING});
11228
	$expectation->at($_[1]);
11229
 
11230
	my $thisline;
11231
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
11232
 
11233
 
11234
 
11235
	while (!$_matched && !$commit)
11236
	{
11237
 
11238
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
11239
					  Parse::RecDescent::_tracefirst($_[1]),
11240
					  q{sourceroute},
11241
					  $tracelevel)
11242
						if defined $::RD_TRACE;
11243
		my $thisprod = $thisrule->{"prods"}[0];
11244
		$text = $_[1];
11245
		my $_savetext;
11246
		@item = (q{sourceroute});
11247
		%item = (__RULE__ => q{sourceroute});
11248
		my $repcount = 0;
11249
 
11250
 
11251
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
11252
				  Parse::RecDescent::_tracefirst($text),
11253
				  q{sourceroute},
11254
				  $tracelevel)
11255
					if defined $::RD_TRACE;
11256
		if (1) { no strict qw{refs};
11257
		$expectation->is(q{})->at($text);
11258
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
11259
		{
11260
 
11261
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
11262
						  Parse::RecDescent::_tracefirst($text),
11263
						  q{sourceroute},
11264
						  $tracelevel)
11265
							if defined $::RD_TRACE;
11266
			$expectation->failed();
11267
			last;
11268
		}
11269
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
11270
					. $_tok . q{]},
11271
 
11272
					  Parse::RecDescent::_tracefirst($text),
11273
					  q{sourceroute},
11274
					  $tracelevel)
11275
						if defined $::RD_TRACE;
11276
		$item{q{NIL}} = $_tok;
11277
		push @item, $_tok;
11278
 
11279
		}
11280
 
11281
 
11282
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
11283
					  Parse::RecDescent::_tracefirst($text),
11284
					  q{sourceroute},
11285
					  $tracelevel)
11286
						if defined $::RD_TRACE;
11287
		$_matched = 1;
11288
		last;
11289
	}
11290
 
11291
		splice
11292
				@{$thisparser->{deferred}}, $def_at unless $_matched;
11293
 
11294
	while (!$_matched && !$commit)
11295
	{
11296
 
11297
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
11298
					  Parse::RecDescent::_tracefirst($_[1]),
11299
					  q{sourceroute},
11300
					  $tracelevel)
11301
						if defined $::RD_TRACE;
11302
		my $thisprod = $thisrule->{"prods"}[1];
11303
		$text = $_[1];
11304
		my $_savetext;
11305
		@item = (q{sourceroute});
11306
		%item = (__RULE__ => q{sourceroute});
11307
		my $repcount = 0;
11308
 
11309
 
11310
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
11311
				  Parse::RecDescent::_tracefirst($text),
11312
				  q{sourceroute},
11313
				  $tracelevel)
11314
					if defined $::RD_TRACE;
11315
		if (1) { no strict qw{refs};
11316
		$expectation->is(q{})->at($text);
11317
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
11318
		{
11319
 
11320
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
11321
						  Parse::RecDescent::_tracefirst($text),
11322
						  q{sourceroute},
11323
						  $tracelevel)
11324
							if defined $::RD_TRACE;
11325
			$expectation->failed();
11326
			last;
11327
		}
11328
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
11329
					. $_tok . q{]},
11330
 
11331
					  Parse::RecDescent::_tracefirst($text),
11332
					  q{sourceroute},
11333
					  $tracelevel)
11334
						if defined $::RD_TRACE;
11335
		$item{q{STRING}} = $_tok;
11336
		push @item, $_tok;
11337
 
11338
		}
11339
 
11340
		Parse::RecDescent::_trace(q{Trying action},
11341
					  Parse::RecDescent::_tracefirst($text),
11342
					  q{sourceroute},
11343
					  $tracelevel)
11344
						if defined $::RD_TRACE;
11345
 
11346
 
11347
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{STRING} ;$return||defined($return);};
11348
		unless (defined $_tok)
11349
		{
11350
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
11351
					if defined $::RD_TRACE;
11352
			last;
11353
		}
11354
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
11355
					  . $_tok . q{])},
11356
					  Parse::RecDescent::_tracefirst($text))
11357
						if defined $::RD_TRACE;
11358
		push @item, $_tok;
11359
		$item{__ACTION1__}=$_tok;
11360
 
11361
 
11362
 
11363
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
11364
					  Parse::RecDescent::_tracefirst($text),
11365
					  q{sourceroute},
11366
					  $tracelevel)
11367
						if defined $::RD_TRACE;
11368
		$_matched = 1;
11369
		last;
11370
	}
11371
 
11372
		splice
11373
				@{$thisparser->{deferred}}, $def_at unless $_matched;
11374
 
11375
        unless ( $_matched || defined($score) )
11376
	{
11377
				splice @{$thisparser->{deferred}}, $def_at;
11378
 
11379
 
11380
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
11381
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
11382
					 Parse::RecDescent::_tracefirst($_[1]),
11383
					 q{sourceroute},
11384
					 $tracelevel)
11385
					if defined $::RD_TRACE;
11386
		return undef;
11387
	}
11388
	if (!defined($return) && defined($score))
11389
	{
11390
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
11391
					  q{sourceroute},
11392
					  $tracelevel)
11393
						if defined $::RD_TRACE;
11394
		$return = $score_return;
11395
	}
11396
	splice @{$thisparser->{errors}}, $err_at;
11397
	$return = $item[$#item] unless defined $return;
11398
	if (defined $::RD_TRACE)
11399
	{
11400
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
11401
					  $return . q{])}, "",
11402
					  q{sourceroute},
11403
					  $tracelevel);
11404
		Parse::RecDescent::_trace(q{(consumed: [} .
11405
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
11406
					  Parse::RecDescent::_tracefirst($text),
11407
					  , q{sourceroute},
11408
					  $tracelevel)
11409
	}
11410
	$_[1] = $text;
11411
	return $return;
11412
}
11413
 
11414
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
11415
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::subpart
11416
{
11417
	my $thisparser = $_[0];
11418
	use vars q{$tracelevel};
11419
	local $tracelevel = ($tracelevel||0)+1;
11420
	$ERRORS = 0;
11421
	my $thisrule = $thisparser->{"rules"}{"subpart"};
11422
 
11423
	Parse::RecDescent::_trace(q{Trying rule: [subpart]},
11424
				  Parse::RecDescent::_tracefirst($_[1]),
11425
				  q{subpart},
11426
				  $tracelevel)
11427
					if defined $::RD_TRACE;
11428
 
11429
	my $def_at = @{$thisparser->{deferred}};
11430
	my $err_at = @{$thisparser->{errors}};
11431
 
11432
	my $score;
11433
	my $score_return;
11434
	my $_tok;
11435
	my $return = undef;
11436
	my $_matched=0;
11437
	my $commit=0;
11438
	my @item = ();
11439
	my %item = ();
11440
	my $repeating =  defined($_[2]) && $_[2];
11441
	my $_noactions = defined($_[3]) && $_[3];
11442
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
11443
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
11444
	my $text;
11445
	my $lastsep="";
11446
    my $expectation = new Parse::RecDescent::Expectation(q{'('});
11447
	$expectation->at($_[1]);
11448
 
11449
	my $thisline;
11450
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
11451
 
11452
 
11453
 
11454
	while (!$_matched && !$commit)
11455
	{
11456
 
11457
		Parse::RecDescent::_trace(q{Trying production: ['(' part ')' <defer:{  ++$subpartCount; }>]},
11458
					  Parse::RecDescent::_tracefirst($_[1]),
11459
					  q{subpart},
11460
					  $tracelevel)
11461
						if defined $::RD_TRACE;
11462
		my $thisprod = $thisrule->{"prods"}[0];
11463
		$text = $_[1];
11464
		my $_savetext;
11465
		@item = (q{subpart});
11466
		%item = (__RULE__ => q{subpart});
11467
		my $repcount = 0;
11468
 
11469
 
11470
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
11471
					  Parse::RecDescent::_tracefirst($text),
11472
					  q{subpart},
11473
					  $tracelevel)
11474
						if defined $::RD_TRACE;
11475
		$lastsep = "";
11476
		$expectation->is(q{})->at($text);
11477
 
11478
 
11479
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "("; 1 } and
11480
		     substr($text,0,length($_tok)) eq $_tok and
11481
		     do { substr($text,0,length($_tok)) = ""; 1; }
11482
		)
11483
		{
11484
 
11485
			$expectation->failed();
11486
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
11487
						  Parse::RecDescent::_tracefirst($text))
11488
							if defined $::RD_TRACE;
11489
			last;
11490
		}
11491
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
11492
						. $_tok . q{])},
11493
						  Parse::RecDescent::_tracefirst($text))
11494
							if defined $::RD_TRACE;
11495
		push @item, $item{__STRING1__}=$_tok;
11496
 
11497
 
11498
		Parse::RecDescent::_trace(q{Trying subrule: [part]},
11499
				  Parse::RecDescent::_tracefirst($text),
11500
				  q{subpart},
11501
				  $tracelevel)
11502
					if defined $::RD_TRACE;
11503
		if (1) { no strict qw{refs};
11504
		$expectation->is(q{part})->at($text);
11505
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::part($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
11506
		{
11507
 
11508
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [part]>>},
11509
						  Parse::RecDescent::_tracefirst($text),
11510
						  q{subpart},
11511
						  $tracelevel)
11512
							if defined $::RD_TRACE;
11513
			$expectation->failed();
11514
			last;
11515
		}
11516
		Parse::RecDescent::_trace(q{>>Matched subrule: [part]<< (return value: [}
11517
					. $_tok . q{]},
11518
 
11519
					  Parse::RecDescent::_tracefirst($text),
11520
					  q{subpart},
11521
					  $tracelevel)
11522
						if defined $::RD_TRACE;
11523
		$item{q{part}} = $_tok;
11524
		push @item, $_tok;
11525
 
11526
		}
11527
 
11528
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
11529
					  Parse::RecDescent::_tracefirst($text),
11530
					  q{subpart},
11531
					  $tracelevel)
11532
						if defined $::RD_TRACE;
11533
		$lastsep = "";
11534
		$expectation->is(q{')'})->at($text);
11535
 
11536
 
11537
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
11538
		     substr($text,0,length($_tok)) eq $_tok and
11539
		     do { substr($text,0,length($_tok)) = ""; 1; }
11540
		)
11541
		{
11542
 
11543
			$expectation->failed();
11544
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
11545
						  Parse::RecDescent::_tracefirst($text))
11546
							if defined $::RD_TRACE;
11547
			last;
11548
		}
11549
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
11550
						. $_tok . q{])},
11551
						  Parse::RecDescent::_tracefirst($text))
11552
							if defined $::RD_TRACE;
11553
		push @item, $item{__STRING2__}=$_tok;
11554
 
11555
 
11556
		Parse::RecDescent::_trace(q{Trying action},
11557
					  Parse::RecDescent::_tracefirst($text),
11558
					  q{subpart},
11559
					  $tracelevel)
11560
						if defined $::RD_TRACE;
11561
 
11562
 
11563
		$_tok = ($_noactions) ? 0 : do { 
11564
		$return = $item{part} ; 
11565
		$return||defined($return);
11566
	};
11567
		unless (defined $_tok)
11568
		{
11569
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
11570
					if defined $::RD_TRACE;
11571
			last;
11572
		}
11573
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
11574
					  . $_tok . q{])},
11575
					  Parse::RecDescent::_tracefirst($text))
11576
						if defined $::RD_TRACE;
11577
		push @item, $_tok;
11578
		$item{__ACTION1__}=$_tok;
11579
 
11580
 
11581
 
11582
 
11583
		Parse::RecDescent::_trace(q{Trying directive: [<defer:{  ++$subpartCount; }>]},
11584
					Parse::RecDescent::_tracefirst($text),
11585
					  q{subpart},
11586
					  $tracelevel)
11587
						if defined $::RD_TRACE; 
11588
		$_tok = do { push @{$thisparser->{deferred}}, sub {  ++$subpartCount; }; };
11589
		if (defined($_tok))
11590
		{
11591
			Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
11592
						. $_tok . q{])},
11593
						Parse::RecDescent::_tracefirst($text))
11594
							if defined $::RD_TRACE;
11595
		}
11596
		else
11597
		{
11598
			Parse::RecDescent::_trace(q{<<Didn't match directive>>},
11599
						Parse::RecDescent::_tracefirst($text))
11600
							if defined $::RD_TRACE;
11601
		}
11602
 
11603
		last unless defined $_tok;
11604
		push @item, $item{__DIRECTIVE1__}=$_tok;
11605
 
11606
 
11607
 
11608
		Parse::RecDescent::_trace(q{>>Matched production: ['(' part ')' <defer:{  ++$subpartCount; }>]<<},
11609
					  Parse::RecDescent::_tracefirst($text),
11610
					  q{subpart},
11611
					  $tracelevel)
11612
						if defined $::RD_TRACE;
11613
		$_matched = 1;
11614
		last;
11615
	}
11616
 
11617
		splice
11618
				@{$thisparser->{deferred}}, $def_at unless $_matched;
11619
 
11620
        unless ( $_matched || defined($score) )
11621
	{
11622
				splice @{$thisparser->{deferred}}, $def_at;
11623
 
11624
 
11625
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
11626
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
11627
					 Parse::RecDescent::_tracefirst($_[1]),
11628
					 q{subpart},
11629
					 $tracelevel)
11630
					if defined $::RD_TRACE;
11631
		return undef;
11632
	}
11633
	if (!defined($return) && defined($score))
11634
	{
11635
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
11636
					  q{subpart},
11637
					  $tracelevel)
11638
						if defined $::RD_TRACE;
11639
		$return = $score_return;
11640
	}
11641
	splice @{$thisparser->{errors}}, $err_at;
11642
	$return = $item[$#item] unless defined $return;
11643
	if (defined $::RD_TRACE)
11644
	{
11645
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
11646
					  $return . q{])}, "",
11647
					  q{subpart},
11648
					  $tracelevel);
11649
		Parse::RecDescent::_trace(q{(consumed: [} .
11650
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
11651
					  Parse::RecDescent::_tracefirst($text),
11652
					  , q{subpart},
11653
					  $tracelevel)
11654
	}
11655
	$_[1] = $text;
11656
	return $return;
11657
}
11658
 
11659
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
11660
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::textlines
11661
{
11662
	my $thisparser = $_[0];
11663
	use vars q{$tracelevel};
11664
	local $tracelevel = ($tracelevel||0)+1;
11665
	$ERRORS = 0;
11666
	my $thisrule = $thisparser->{"rules"}{"textlines"};
11667
 
11668
	Parse::RecDescent::_trace(q{Trying rule: [textlines]},
11669
				  Parse::RecDescent::_tracefirst($_[1]),
11670
				  q{textlines},
11671
				  $tracelevel)
11672
					if defined $::RD_TRACE;
11673
 
11674
	my $def_at = @{$thisparser->{deferred}};
11675
	my $err_at = @{$thisparser->{errors}};
11676
 
11677
	my $score;
11678
	my $score_return;
11679
	my $_tok;
11680
	my $return = undef;
11681
	my $_matched=0;
11682
	my $commit=0;
11683
	my @item = ();
11684
	my %item = ();
11685
	my $repeating =  defined($_[2]) && $_[2];
11686
	my $_noactions = defined($_[3]) && $_[3];
11687
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
11688
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
11689
	my $text;
11690
	my $lastsep="";
11691
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or NUMBER});
11692
	$expectation->at($_[1]);
11693
 
11694
	my $thisline;
11695
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
11696
 
11697
 
11698
 
11699
	while (!$_matched && !$commit)
11700
	{
11701
 
11702
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
11703
					  Parse::RecDescent::_tracefirst($_[1]),
11704
					  q{textlines},
11705
					  $tracelevel)
11706
						if defined $::RD_TRACE;
11707
		my $thisprod = $thisrule->{"prods"}[0];
11708
		$text = $_[1];
11709
		my $_savetext;
11710
		@item = (q{textlines});
11711
		%item = (__RULE__ => q{textlines});
11712
		my $repcount = 0;
11713
 
11714
 
11715
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
11716
				  Parse::RecDescent::_tracefirst($text),
11717
				  q{textlines},
11718
				  $tracelevel)
11719
					if defined $::RD_TRACE;
11720
		if (1) { no strict qw{refs};
11721
		$expectation->is(q{})->at($text);
11722
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
11723
		{
11724
 
11725
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
11726
						  Parse::RecDescent::_tracefirst($text),
11727
						  q{textlines},
11728
						  $tracelevel)
11729
							if defined $::RD_TRACE;
11730
			$expectation->failed();
11731
			last;
11732
		}
11733
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
11734
					. $_tok . q{]},
11735
 
11736
					  Parse::RecDescent::_tracefirst($text),
11737
					  q{textlines},
11738
					  $tracelevel)
11739
						if defined $::RD_TRACE;
11740
		$item{q{NIL}} = $_tok;
11741
		push @item, $_tok;
11742
 
11743
		}
11744
 
11745
 
11746
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
11747
					  Parse::RecDescent::_tracefirst($text),
11748
					  q{textlines},
11749
					  $tracelevel)
11750
						if defined $::RD_TRACE;
11751
		$_matched = 1;
11752
		last;
11753
	}
11754
 
11755
		splice
11756
				@{$thisparser->{deferred}}, $def_at unless $_matched;
11757
 
11758
	while (!$_matched && !$commit)
11759
	{
11760
 
11761
		Parse::RecDescent::_trace(q{Trying production: [NUMBER]},
11762
					  Parse::RecDescent::_tracefirst($_[1]),
11763
					  q{textlines},
11764
					  $tracelevel)
11765
						if defined $::RD_TRACE;
11766
		my $thisprod = $thisrule->{"prods"}[1];
11767
		$text = $_[1];
11768
		my $_savetext;
11769
		@item = (q{textlines});
11770
		%item = (__RULE__ => q{textlines});
11771
		my $repcount = 0;
11772
 
11773
 
11774
		Parse::RecDescent::_trace(q{Trying subrule: [NUMBER]},
11775
				  Parse::RecDescent::_tracefirst($text),
11776
				  q{textlines},
11777
				  $tracelevel)
11778
					if defined $::RD_TRACE;
11779
		if (1) { no strict qw{refs};
11780
		$expectation->is(q{})->at($text);
11781
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NUMBER($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
11782
		{
11783
 
11784
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NUMBER]>>},
11785
						  Parse::RecDescent::_tracefirst($text),
11786
						  q{textlines},
11787
						  $tracelevel)
11788
							if defined $::RD_TRACE;
11789
			$expectation->failed();
11790
			last;
11791
		}
11792
		Parse::RecDescent::_trace(q{>>Matched subrule: [NUMBER]<< (return value: [}
11793
					. $_tok . q{]},
11794
 
11795
					  Parse::RecDescent::_tracefirst($text),
11796
					  q{textlines},
11797
					  $tracelevel)
11798
						if defined $::RD_TRACE;
11799
		$item{q{NUMBER}} = $_tok;
11800
		push @item, $_tok;
11801
 
11802
		}
11803
 
11804
		Parse::RecDescent::_trace(q{Trying action},
11805
					  Parse::RecDescent::_tracefirst($text),
11806
					  q{textlines},
11807
					  $tracelevel)
11808
						if defined $::RD_TRACE;
11809
 
11810
 
11811
		$_tok = ($_noactions) ? 0 : do { $return = $item[1] || $item[2]; $return||defined($return); };
11812
		unless (defined $_tok)
11813
		{
11814
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
11815
					if defined $::RD_TRACE;
11816
			last;
11817
		}
11818
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
11819
					  . $_tok . q{])},
11820
					  Parse::RecDescent::_tracefirst($text))
11821
						if defined $::RD_TRACE;
11822
		push @item, $_tok;
11823
		$item{__ACTION1__}=$_tok;
11824
 
11825
 
11826
 
11827
		Parse::RecDescent::_trace(q{>>Matched production: [NUMBER]<<},
11828
					  Parse::RecDescent::_tracefirst($text),
11829
					  q{textlines},
11830
					  $tracelevel)
11831
						if defined $::RD_TRACE;
11832
		$_matched = 1;
11833
		last;
11834
	}
11835
 
11836
		splice
11837
				@{$thisparser->{deferred}}, $def_at unless $_matched;
11838
 
11839
        unless ( $_matched || defined($score) )
11840
	{
11841
				splice @{$thisparser->{deferred}}, $def_at;
11842
 
11843
 
11844
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
11845
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
11846
					 Parse::RecDescent::_tracefirst($_[1]),
11847
					 q{textlines},
11848
					 $tracelevel)
11849
					if defined $::RD_TRACE;
11850
		return undef;
11851
	}
11852
	if (!defined($return) && defined($score))
11853
	{
11854
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
11855
					  q{textlines},
11856
					  $tracelevel)
11857
						if defined $::RD_TRACE;
11858
		$return = $score_return;
11859
	}
11860
	splice @{$thisparser->{errors}}, $err_at;
11861
	$return = $item[$#item] unless defined $return;
11862
	if (defined $::RD_TRACE)
11863
	{
11864
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
11865
					  $return . q{])}, "",
11866
					  q{textlines},
11867
					  $tracelevel);
11868
		Parse::RecDescent::_trace(q{(consumed: [} .
11869
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
11870
					  Parse::RecDescent::_tracefirst($text),
11871
					  , q{textlines},
11872
					  $tracelevel)
11873
	}
11874
	$_[1] = $text;
11875
	return $return;
11876
}
11877
 
11878
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
11879
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::BARESTRING
11880
{
11881
	my $thisparser = $_[0];
11882
	use vars q{$tracelevel};
11883
	local $tracelevel = ($tracelevel||0)+1;
11884
	$ERRORS = 0;
11885
	my $thisrule = $thisparser->{"rules"}{"BARESTRING"};
11886
 
11887
	Parse::RecDescent::_trace(q{Trying rule: [BARESTRING]},
11888
				  Parse::RecDescent::_tracefirst($_[1]),
11889
				  q{BARESTRING},
11890
				  $tracelevel)
11891
					if defined $::RD_TRACE;
11892
 
11893
	my $def_at = @{$thisparser->{deferred}};
11894
	my $err_at = @{$thisparser->{errors}};
11895
 
11896
	my $score;
11897
	my $score_return;
11898
	my $_tok;
11899
	my $return = undef;
11900
	my $_matched=0;
11901
	my $commit=0;
11902
	my @item = ();
11903
	my %item = ();
11904
	my $repeating =  defined($_[2]) && $_[2];
11905
	my $_noactions = defined($_[3]) && $_[3];
11906
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
11907
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
11908
	my $text;
11909
	my $lastsep="";
11910
    my $expectation = new Parse::RecDescent::Expectation(q{/^[)('"]/});
11911
	$expectation->at($_[1]);
11912
 
11913
	my $thisline;
11914
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
11915
 
11916
 
11917
 
11918
	while (!$_matched && !$commit)
11919
	{
11920
 
11921
		Parse::RecDescent::_trace(q{Trying production: [/^[)('"]/ /^(?!\\(|\\))(?:\\\\ |\\S)+/]},
11922
					  Parse::RecDescent::_tracefirst($_[1]),
11923
					  q{BARESTRING},
11924
					  $tracelevel)
11925
						if defined $::RD_TRACE;
11926
		my $thisprod = $thisrule->{"prods"}[0];
11927
		$text = $_[1];
11928
		my $_savetext;
11929
		@item = (q{BARESTRING});
11930
		%item = (__RULE__ => q{BARESTRING});
11931
		my $repcount = 0;
11932
 
11933
 
11934
		Parse::RecDescent::_trace(q{Trying terminal: [/^[)('"]/]}, Parse::RecDescent::_tracefirst($text),
11935
					  q{BARESTRING},
11936
					  $tracelevel)
11937
						if defined $::RD_TRACE;
11938
		$lastsep = "";
11939
		$expectation->is(q{})->at($text);
11940
		$_savetext = $text;
11941
 
11942
		if ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:^[)('"])//)
11943
		{
11944
			$text = $_savetext;
11945
			$expectation->failed();
11946
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
11947
						  Parse::RecDescent::_tracefirst($text))
11948
					if defined $::RD_TRACE;
11949
 
11950
			last;
11951
		}
11952
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
11953
						. $& . q{])},
11954
						  Parse::RecDescent::_tracefirst($text))
11955
					if defined $::RD_TRACE;
11956
		push @item, $item{__PATTERN1__}=$&;
11957
		$text = $_savetext;
11958
 
11959
		Parse::RecDescent::_trace(q{Trying terminal: [/^(?!\\(|\\))(?:\\\\ |\\S)+/]}, Parse::RecDescent::_tracefirst($text),
11960
					  q{BARESTRING},
11961
					  $tracelevel)
11962
						if defined $::RD_TRACE;
11963
		$lastsep = "";
11964
		$expectation->is(q{/^(?!\\(|\\))(?:\\\\ |\\S)+/})->at($text);
11965
 
11966
 
11967
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ s/\A(?:^(?!\(|\))(?:\\ |\S)+)//)
11968
		{
11969
 
11970
			$expectation->failed();
11971
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
11972
						  Parse::RecDescent::_tracefirst($text))
11973
					if defined $::RD_TRACE;
11974
 
11975
			last;
11976
		}
11977
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
11978
						. $& . q{])},
11979
						  Parse::RecDescent::_tracefirst($text))
11980
					if defined $::RD_TRACE;
11981
		push @item, $item{__PATTERN2__}=$&;
11982
 
11983
 
11984
		Parse::RecDescent::_trace(q{Trying action},
11985
					  Parse::RecDescent::_tracefirst($text),
11986
					  q{BARESTRING},
11987
					  $tracelevel)
11988
						if defined $::RD_TRACE;
11989
 
11990
 
11991
		$_tok = ($_noactions) ? 0 : do { 
11992
	$return = $item{__PATTERN1__} ; $return||defined($return);
11993
};
11994
		unless (defined $_tok)
11995
		{
11996
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
11997
					if defined $::RD_TRACE;
11998
			last;
11999
		}
12000
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
12001
					  . $_tok . q{])},
12002
					  Parse::RecDescent::_tracefirst($text))
12003
						if defined $::RD_TRACE;
12004
		push @item, $_tok;
12005
		$item{__ACTION1__}=$_tok;
12006
 
12007
 
12008
 
12009
		Parse::RecDescent::_trace(q{>>Matched production: [/^[)('"]/ /^(?!\\(|\\))(?:\\\\ |\\S)+/]<<},
12010
					  Parse::RecDescent::_tracefirst($text),
12011
					  q{BARESTRING},
12012
					  $tracelevel)
12013
						if defined $::RD_TRACE;
12014
		$_matched = 1;
12015
		last;
12016
	}
12017
 
12018
		splice
12019
				@{$thisparser->{deferred}}, $def_at unless $_matched;
12020
 
12021
        unless ( $_matched || defined($score) )
12022
	{
12023
				splice @{$thisparser->{deferred}}, $def_at;
12024
 
12025
 
12026
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
12027
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
12028
					 Parse::RecDescent::_tracefirst($_[1]),
12029
					 q{BARESTRING},
12030
					 $tracelevel)
12031
					if defined $::RD_TRACE;
12032
		return undef;
12033
	}
12034
	if (!defined($return) && defined($score))
12035
	{
12036
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
12037
					  q{BARESTRING},
12038
					  $tracelevel)
12039
						if defined $::RD_TRACE;
12040
		$return = $score_return;
12041
	}
12042
	splice @{$thisparser->{errors}}, $err_at;
12043
	$return = $item[$#item] unless defined $return;
12044
	if (defined $::RD_TRACE)
12045
	{
12046
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
12047
					  $return . q{])}, "",
12048
					  q{BARESTRING},
12049
					  $tracelevel);
12050
		Parse::RecDescent::_trace(q{(consumed: [} .
12051
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
12052
					  Parse::RecDescent::_tracefirst($text),
12053
					  , q{BARESTRING},
12054
					  $tracelevel)
12055
	}
12056
	$_[1] = $text;
12057
	return $return;
12058
}
12059
 
12060
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
12061
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bodylang
12062
{
12063
	my $thisparser = $_[0];
12064
	use vars q{$tracelevel};
12065
	local $tracelevel = ($tracelevel||0)+1;
12066
	$ERRORS = 0;
12067
	my $thisrule = $thisparser->{"rules"}{"bodylang"};
12068
 
12069
	Parse::RecDescent::_trace(q{Trying rule: [bodylang]},
12070
				  Parse::RecDescent::_tracefirst($_[1]),
12071
				  q{bodylang},
12072
				  $tracelevel)
12073
					if defined $::RD_TRACE;
12074
 
12075
	my $def_at = @{$thisparser->{deferred}};
12076
	my $err_at = @{$thisparser->{errors}};
12077
 
12078
	my $score;
12079
	my $score_return;
12080
	my $_tok;
12081
	my $return = undef;
12082
	my $_matched=0;
12083
	my $commit=0;
12084
	my @item = ();
12085
	my %item = ();
12086
	my $repeating =  defined($_[2]) && $_[2];
12087
	my $_noactions = defined($_[3]) && $_[3];
12088
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
12089
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
12090
	my $text;
12091
	my $lastsep="";
12092
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or STRING, or '('});
12093
	$expectation->at($_[1]);
12094
 
12095
	my $thisline;
12096
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
12097
 
12098
 
12099
 
12100
	while (!$_matched && !$commit)
12101
	{
12102
 
12103
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
12104
					  Parse::RecDescent::_tracefirst($_[1]),
12105
					  q{bodylang},
12106
					  $tracelevel)
12107
						if defined $::RD_TRACE;
12108
		my $thisprod = $thisrule->{"prods"}[0];
12109
		$text = $_[1];
12110
		my $_savetext;
12111
		@item = (q{bodylang});
12112
		%item = (__RULE__ => q{bodylang});
12113
		my $repcount = 0;
12114
 
12115
 
12116
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
12117
				  Parse::RecDescent::_tracefirst($text),
12118
				  q{bodylang},
12119
				  $tracelevel)
12120
					if defined $::RD_TRACE;
12121
		if (1) { no strict qw{refs};
12122
		$expectation->is(q{})->at($text);
12123
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12124
		{
12125
 
12126
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
12127
						  Parse::RecDescent::_tracefirst($text),
12128
						  q{bodylang},
12129
						  $tracelevel)
12130
							if defined $::RD_TRACE;
12131
			$expectation->failed();
12132
			last;
12133
		}
12134
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
12135
					. $_tok . q{]},
12136
 
12137
					  Parse::RecDescent::_tracefirst($text),
12138
					  q{bodylang},
12139
					  $tracelevel)
12140
						if defined $::RD_TRACE;
12141
		$item{q{NIL}} = $_tok;
12142
		push @item, $_tok;
12143
 
12144
		}
12145
 
12146
 
12147
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
12148
					  Parse::RecDescent::_tracefirst($text),
12149
					  q{bodylang},
12150
					  $tracelevel)
12151
						if defined $::RD_TRACE;
12152
		$_matched = 1;
12153
		last;
12154
	}
12155
 
12156
		splice
12157
				@{$thisparser->{deferred}}, $def_at unless $_matched;
12158
 
12159
	while (!$_matched && !$commit)
12160
	{
12161
 
12162
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
12163
					  Parse::RecDescent::_tracefirst($_[1]),
12164
					  q{bodylang},
12165
					  $tracelevel)
12166
						if defined $::RD_TRACE;
12167
		my $thisprod = $thisrule->{"prods"}[1];
12168
		$text = $_[1];
12169
		my $_savetext;
12170
		@item = (q{bodylang});
12171
		%item = (__RULE__ => q{bodylang});
12172
		my $repcount = 0;
12173
 
12174
 
12175
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
12176
				  Parse::RecDescent::_tracefirst($text),
12177
				  q{bodylang},
12178
				  $tracelevel)
12179
					if defined $::RD_TRACE;
12180
		if (1) { no strict qw{refs};
12181
		$expectation->is(q{})->at($text);
12182
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12183
		{
12184
 
12185
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
12186
						  Parse::RecDescent::_tracefirst($text),
12187
						  q{bodylang},
12188
						  $tracelevel)
12189
							if defined $::RD_TRACE;
12190
			$expectation->failed();
12191
			last;
12192
		}
12193
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
12194
					. $_tok . q{]},
12195
 
12196
					  Parse::RecDescent::_tracefirst($text),
12197
					  q{bodylang},
12198
					  $tracelevel)
12199
						if defined $::RD_TRACE;
12200
		$item{q{STRING}} = $_tok;
12201
		push @item, $_tok;
12202
 
12203
		}
12204
 
12205
 
12206
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
12207
					  Parse::RecDescent::_tracefirst($text),
12208
					  q{bodylang},
12209
					  $tracelevel)
12210
						if defined $::RD_TRACE;
12211
		$_matched = 1;
12212
		last;
12213
	}
12214
 
12215
		splice
12216
				@{$thisparser->{deferred}}, $def_at unless $_matched;
12217
 
12218
	while (!$_matched && !$commit)
12219
	{
12220
 
12221
		Parse::RecDescent::_trace(q{Trying production: ['(' STRING ')']},
12222
					  Parse::RecDescent::_tracefirst($_[1]),
12223
					  q{bodylang},
12224
					  $tracelevel)
12225
						if defined $::RD_TRACE;
12226
		my $thisprod = $thisrule->{"prods"}[2];
12227
		$text = $_[1];
12228
		my $_savetext;
12229
		@item = (q{bodylang});
12230
		%item = (__RULE__ => q{bodylang});
12231
		my $repcount = 0;
12232
 
12233
 
12234
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
12235
					  Parse::RecDescent::_tracefirst($text),
12236
					  q{bodylang},
12237
					  $tracelevel)
12238
						if defined $::RD_TRACE;
12239
		$lastsep = "";
12240
		$expectation->is(q{})->at($text);
12241
 
12242
 
12243
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "("; 1 } and
12244
		     substr($text,0,length($_tok)) eq $_tok and
12245
		     do { substr($text,0,length($_tok)) = ""; 1; }
12246
		)
12247
		{
12248
 
12249
			$expectation->failed();
12250
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
12251
						  Parse::RecDescent::_tracefirst($text))
12252
							if defined $::RD_TRACE;
12253
			last;
12254
		}
12255
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
12256
						. $_tok . q{])},
12257
						  Parse::RecDescent::_tracefirst($text))
12258
							if defined $::RD_TRACE;
12259
		push @item, $item{__STRING1__}=$_tok;
12260
 
12261
 
12262
		Parse::RecDescent::_trace(q{Trying repeated subrule: [STRING]},
12263
				  Parse::RecDescent::_tracefirst($text),
12264
				  q{bodylang},
12265
				  $tracelevel)
12266
					if defined $::RD_TRACE;
12267
		$expectation->is(q{STRING})->at($text);
12268
 
12269
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
12270
		{
12271
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [STRING]>>},
12272
						  Parse::RecDescent::_tracefirst($text),
12273
						  q{bodylang},
12274
						  $tracelevel)
12275
							if defined $::RD_TRACE;
12276
			last;
12277
		}
12278
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [STRING]<< (}
12279
					. @$_tok . q{ times)},
12280
 
12281
					  Parse::RecDescent::_tracefirst($text),
12282
					  q{bodylang},
12283
					  $tracelevel)
12284
						if defined $::RD_TRACE;
12285
		$item{q{STRING(s)}} = $_tok;
12286
		push @item, $_tok;
12287
 
12288
 
12289
 
12290
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
12291
					  Parse::RecDescent::_tracefirst($text),
12292
					  q{bodylang},
12293
					  $tracelevel)
12294
						if defined $::RD_TRACE;
12295
		$lastsep = "";
12296
		$expectation->is(q{')'})->at($text);
12297
 
12298
 
12299
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
12300
		     substr($text,0,length($_tok)) eq $_tok and
12301
		     do { substr($text,0,length($_tok)) = ""; 1; }
12302
		)
12303
		{
12304
 
12305
			$expectation->failed();
12306
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
12307
						  Parse::RecDescent::_tracefirst($text))
12308
							if defined $::RD_TRACE;
12309
			last;
12310
		}
12311
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
12312
						. $_tok . q{])},
12313
						  Parse::RecDescent::_tracefirst($text))
12314
							if defined $::RD_TRACE;
12315
		push @item, $item{__STRING2__}=$_tok;
12316
 
12317
 
12318
		Parse::RecDescent::_trace(q{Trying action},
12319
					  Parse::RecDescent::_tracefirst($text),
12320
					  q{bodylang},
12321
					  $tracelevel)
12322
						if defined $::RD_TRACE;
12323
 
12324
 
12325
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{'STRING(s)'} ;$return||defined($return);};
12326
		unless (defined $_tok)
12327
		{
12328
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
12329
					if defined $::RD_TRACE;
12330
			last;
12331
		}
12332
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
12333
					  . $_tok . q{])},
12334
					  Parse::RecDescent::_tracefirst($text))
12335
						if defined $::RD_TRACE;
12336
		push @item, $_tok;
12337
		$item{__ACTION1__}=$_tok;
12338
 
12339
 
12340
 
12341
		Parse::RecDescent::_trace(q{>>Matched production: ['(' STRING ')']<<},
12342
					  Parse::RecDescent::_tracefirst($text),
12343
					  q{bodylang},
12344
					  $tracelevel)
12345
						if defined $::RD_TRACE;
12346
		$_matched = 1;
12347
		last;
12348
	}
12349
 
12350
		splice
12351
				@{$thisparser->{deferred}}, $def_at unless $_matched;
12352
 
12353
        unless ( $_matched || defined($score) )
12354
	{
12355
				splice @{$thisparser->{deferred}}, $def_at;
12356
 
12357
 
12358
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
12359
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
12360
					 Parse::RecDescent::_tracefirst($_[1]),
12361
					 q{bodylang},
12362
					 $tracelevel)
12363
					if defined $::RD_TRACE;
12364
		return undef;
12365
	}
12366
	if (!defined($return) && defined($score))
12367
	{
12368
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
12369
					  q{bodylang},
12370
					  $tracelevel)
12371
						if defined $::RD_TRACE;
12372
		$return = $score_return;
12373
	}
12374
	splice @{$thisparser->{errors}}, $err_at;
12375
	$return = $item[$#item] unless defined $return;
12376
	if (defined $::RD_TRACE)
12377
	{
12378
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
12379
					  $return . q{])}, "",
12380
					  q{bodylang},
12381
					  $tracelevel);
12382
		Parse::RecDescent::_trace(q{(consumed: [} .
12383
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
12384
					  Parse::RecDescent::_tracefirst($text),
12385
					  , q{bodylang},
12386
					  $tracelevel)
12387
	}
12388
	$_[1] = $text;
12389
	return $return;
12390
}
12391
 
12392
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
12393
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::envelopestruct
12394
{
12395
	my $thisparser = $_[0];
12396
	use vars q{$tracelevel};
12397
	local $tracelevel = ($tracelevel||0)+1;
12398
	$ERRORS = 0;
12399
	my $thisrule = $thisparser->{"rules"}{"envelopestruct"};
12400
 
12401
	Parse::RecDescent::_trace(q{Trying rule: [envelopestruct]},
12402
				  Parse::RecDescent::_tracefirst($_[1]),
12403
				  q{envelopestruct},
12404
				  $tracelevel)
12405
					if defined $::RD_TRACE;
12406
 
12407
	my $def_at = @{$thisparser->{deferred}};
12408
	my $err_at = @{$thisparser->{errors}};
12409
 
12410
	my $score;
12411
	my $score_return;
12412
	my $_tok;
12413
	my $return = undef;
12414
	my $_matched=0;
12415
	my $commit=0;
12416
	my @item = ();
12417
	my %item = ();
12418
	my $repeating =  defined($_[2]) && $_[2];
12419
	my $_noactions = defined($_[3]) && $_[3];
12420
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
12421
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
12422
	my $text;
12423
	my $lastsep="";
12424
    my $expectation = new Parse::RecDescent::Expectation(q{'('});
12425
	$expectation->at($_[1]);
12426
 
12427
	my $thisline;
12428
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
12429
 
12430
 
12431
 
12432
	while (!$_matched && !$commit)
12433
	{
12434
 
12435
		Parse::RecDescent::_trace(q{Trying production: ['(' date subject from sender replyto to cc bcc inreplyto messageid ')']},
12436
					  Parse::RecDescent::_tracefirst($_[1]),
12437
					  q{envelopestruct},
12438
					  $tracelevel)
12439
						if defined $::RD_TRACE;
12440
		my $thisprod = $thisrule->{"prods"}[0];
12441
		$text = $_[1];
12442
		my $_savetext;
12443
		@item = (q{envelopestruct});
12444
		%item = (__RULE__ => q{envelopestruct});
12445
		my $repcount = 0;
12446
 
12447
 
12448
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
12449
					  Parse::RecDescent::_tracefirst($text),
12450
					  q{envelopestruct},
12451
					  $tracelevel)
12452
						if defined $::RD_TRACE;
12453
		$lastsep = "";
12454
		$expectation->is(q{})->at($text);
12455
 
12456
 
12457
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "("; 1 } and
12458
		     substr($text,0,length($_tok)) eq $_tok and
12459
		     do { substr($text,0,length($_tok)) = ""; 1; }
12460
		)
12461
		{
12462
 
12463
			$expectation->failed();
12464
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
12465
						  Parse::RecDescent::_tracefirst($text))
12466
							if defined $::RD_TRACE;
12467
			last;
12468
		}
12469
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
12470
						. $_tok . q{])},
12471
						  Parse::RecDescent::_tracefirst($text))
12472
							if defined $::RD_TRACE;
12473
		push @item, $item{__STRING1__}=$_tok;
12474
 
12475
 
12476
		Parse::RecDescent::_trace(q{Trying subrule: [date]},
12477
				  Parse::RecDescent::_tracefirst($text),
12478
				  q{envelopestruct},
12479
				  $tracelevel)
12480
					if defined $::RD_TRACE;
12481
		if (1) { no strict qw{refs};
12482
		$expectation->is(q{date})->at($text);
12483
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::date($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12484
		{
12485
 
12486
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [date]>>},
12487
						  Parse::RecDescent::_tracefirst($text),
12488
						  q{envelopestruct},
12489
						  $tracelevel)
12490
							if defined $::RD_TRACE;
12491
			$expectation->failed();
12492
			last;
12493
		}
12494
		Parse::RecDescent::_trace(q{>>Matched subrule: [date]<< (return value: [}
12495
					. $_tok . q{]},
12496
 
12497
					  Parse::RecDescent::_tracefirst($text),
12498
					  q{envelopestruct},
12499
					  $tracelevel)
12500
						if defined $::RD_TRACE;
12501
		$item{q{date}} = $_tok;
12502
		push @item, $_tok;
12503
 
12504
		}
12505
 
12506
		Parse::RecDescent::_trace(q{Trying subrule: [subject]},
12507
				  Parse::RecDescent::_tracefirst($text),
12508
				  q{envelopestruct},
12509
				  $tracelevel)
12510
					if defined $::RD_TRACE;
12511
		if (1) { no strict qw{refs};
12512
		$expectation->is(q{subject})->at($text);
12513
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::subject($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12514
		{
12515
 
12516
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [subject]>>},
12517
						  Parse::RecDescent::_tracefirst($text),
12518
						  q{envelopestruct},
12519
						  $tracelevel)
12520
							if defined $::RD_TRACE;
12521
			$expectation->failed();
12522
			last;
12523
		}
12524
		Parse::RecDescent::_trace(q{>>Matched subrule: [subject]<< (return value: [}
12525
					. $_tok . q{]},
12526
 
12527
					  Parse::RecDescent::_tracefirst($text),
12528
					  q{envelopestruct},
12529
					  $tracelevel)
12530
						if defined $::RD_TRACE;
12531
		$item{q{subject}} = $_tok;
12532
		push @item, $_tok;
12533
 
12534
		}
12535
 
12536
		Parse::RecDescent::_trace(q{Trying subrule: [from]},
12537
				  Parse::RecDescent::_tracefirst($text),
12538
				  q{envelopestruct},
12539
				  $tracelevel)
12540
					if defined $::RD_TRACE;
12541
		if (1) { no strict qw{refs};
12542
		$expectation->is(q{from})->at($text);
12543
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::from($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12544
		{
12545
 
12546
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [from]>>},
12547
						  Parse::RecDescent::_tracefirst($text),
12548
						  q{envelopestruct},
12549
						  $tracelevel)
12550
							if defined $::RD_TRACE;
12551
			$expectation->failed();
12552
			last;
12553
		}
12554
		Parse::RecDescent::_trace(q{>>Matched subrule: [from]<< (return value: [}
12555
					. $_tok . q{]},
12556
 
12557
					  Parse::RecDescent::_tracefirst($text),
12558
					  q{envelopestruct},
12559
					  $tracelevel)
12560
						if defined $::RD_TRACE;
12561
		$item{q{from}} = $_tok;
12562
		push @item, $_tok;
12563
 
12564
		}
12565
 
12566
		Parse::RecDescent::_trace(q{Trying subrule: [sender]},
12567
				  Parse::RecDescent::_tracefirst($text),
12568
				  q{envelopestruct},
12569
				  $tracelevel)
12570
					if defined $::RD_TRACE;
12571
		if (1) { no strict qw{refs};
12572
		$expectation->is(q{sender})->at($text);
12573
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::sender($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12574
		{
12575
 
12576
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [sender]>>},
12577
						  Parse::RecDescent::_tracefirst($text),
12578
						  q{envelopestruct},
12579
						  $tracelevel)
12580
							if defined $::RD_TRACE;
12581
			$expectation->failed();
12582
			last;
12583
		}
12584
		Parse::RecDescent::_trace(q{>>Matched subrule: [sender]<< (return value: [}
12585
					. $_tok . q{]},
12586
 
12587
					  Parse::RecDescent::_tracefirst($text),
12588
					  q{envelopestruct},
12589
					  $tracelevel)
12590
						if defined $::RD_TRACE;
12591
		$item{q{sender}} = $_tok;
12592
		push @item, $_tok;
12593
 
12594
		}
12595
 
12596
		Parse::RecDescent::_trace(q{Trying subrule: [replyto]},
12597
				  Parse::RecDescent::_tracefirst($text),
12598
				  q{envelopestruct},
12599
				  $tracelevel)
12600
					if defined $::RD_TRACE;
12601
		if (1) { no strict qw{refs};
12602
		$expectation->is(q{replyto})->at($text);
12603
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::replyto($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12604
		{
12605
 
12606
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [replyto]>>},
12607
						  Parse::RecDescent::_tracefirst($text),
12608
						  q{envelopestruct},
12609
						  $tracelevel)
12610
							if defined $::RD_TRACE;
12611
			$expectation->failed();
12612
			last;
12613
		}
12614
		Parse::RecDescent::_trace(q{>>Matched subrule: [replyto]<< (return value: [}
12615
					. $_tok . q{]},
12616
 
12617
					  Parse::RecDescent::_tracefirst($text),
12618
					  q{envelopestruct},
12619
					  $tracelevel)
12620
						if defined $::RD_TRACE;
12621
		$item{q{replyto}} = $_tok;
12622
		push @item, $_tok;
12623
 
12624
		}
12625
 
12626
		Parse::RecDescent::_trace(q{Trying subrule: [to]},
12627
				  Parse::RecDescent::_tracefirst($text),
12628
				  q{envelopestruct},
12629
				  $tracelevel)
12630
					if defined $::RD_TRACE;
12631
		if (1) { no strict qw{refs};
12632
		$expectation->is(q{to})->at($text);
12633
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::to($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12634
		{
12635
 
12636
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [to]>>},
12637
						  Parse::RecDescent::_tracefirst($text),
12638
						  q{envelopestruct},
12639
						  $tracelevel)
12640
							if defined $::RD_TRACE;
12641
			$expectation->failed();
12642
			last;
12643
		}
12644
		Parse::RecDescent::_trace(q{>>Matched subrule: [to]<< (return value: [}
12645
					. $_tok . q{]},
12646
 
12647
					  Parse::RecDescent::_tracefirst($text),
12648
					  q{envelopestruct},
12649
					  $tracelevel)
12650
						if defined $::RD_TRACE;
12651
		$item{q{to}} = $_tok;
12652
		push @item, $_tok;
12653
 
12654
		}
12655
 
12656
		Parse::RecDescent::_trace(q{Trying subrule: [cc]},
12657
				  Parse::RecDescent::_tracefirst($text),
12658
				  q{envelopestruct},
12659
				  $tracelevel)
12660
					if defined $::RD_TRACE;
12661
		if (1) { no strict qw{refs};
12662
		$expectation->is(q{cc})->at($text);
12663
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::cc($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12664
		{
12665
 
12666
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [cc]>>},
12667
						  Parse::RecDescent::_tracefirst($text),
12668
						  q{envelopestruct},
12669
						  $tracelevel)
12670
							if defined $::RD_TRACE;
12671
			$expectation->failed();
12672
			last;
12673
		}
12674
		Parse::RecDescent::_trace(q{>>Matched subrule: [cc]<< (return value: [}
12675
					. $_tok . q{]},
12676
 
12677
					  Parse::RecDescent::_tracefirst($text),
12678
					  q{envelopestruct},
12679
					  $tracelevel)
12680
						if defined $::RD_TRACE;
12681
		$item{q{cc}} = $_tok;
12682
		push @item, $_tok;
12683
 
12684
		}
12685
 
12686
		Parse::RecDescent::_trace(q{Trying subrule: [bcc]},
12687
				  Parse::RecDescent::_tracefirst($text),
12688
				  q{envelopestruct},
12689
				  $tracelevel)
12690
					if defined $::RD_TRACE;
12691
		if (1) { no strict qw{refs};
12692
		$expectation->is(q{bcc})->at($text);
12693
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::bcc($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12694
		{
12695
 
12696
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [bcc]>>},
12697
						  Parse::RecDescent::_tracefirst($text),
12698
						  q{envelopestruct},
12699
						  $tracelevel)
12700
							if defined $::RD_TRACE;
12701
			$expectation->failed();
12702
			last;
12703
		}
12704
		Parse::RecDescent::_trace(q{>>Matched subrule: [bcc]<< (return value: [}
12705
					. $_tok . q{]},
12706
 
12707
					  Parse::RecDescent::_tracefirst($text),
12708
					  q{envelopestruct},
12709
					  $tracelevel)
12710
						if defined $::RD_TRACE;
12711
		$item{q{bcc}} = $_tok;
12712
		push @item, $_tok;
12713
 
12714
		}
12715
 
12716
		Parse::RecDescent::_trace(q{Trying subrule: [inreplyto]},
12717
				  Parse::RecDescent::_tracefirst($text),
12718
				  q{envelopestruct},
12719
				  $tracelevel)
12720
					if defined $::RD_TRACE;
12721
		if (1) { no strict qw{refs};
12722
		$expectation->is(q{inreplyto})->at($text);
12723
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::inreplyto($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12724
		{
12725
 
12726
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [inreplyto]>>},
12727
						  Parse::RecDescent::_tracefirst($text),
12728
						  q{envelopestruct},
12729
						  $tracelevel)
12730
							if defined $::RD_TRACE;
12731
			$expectation->failed();
12732
			last;
12733
		}
12734
		Parse::RecDescent::_trace(q{>>Matched subrule: [inreplyto]<< (return value: [}
12735
					. $_tok . q{]},
12736
 
12737
					  Parse::RecDescent::_tracefirst($text),
12738
					  q{envelopestruct},
12739
					  $tracelevel)
12740
						if defined $::RD_TRACE;
12741
		$item{q{inreplyto}} = $_tok;
12742
		push @item, $_tok;
12743
 
12744
		}
12745
 
12746
		Parse::RecDescent::_trace(q{Trying subrule: [messageid]},
12747
				  Parse::RecDescent::_tracefirst($text),
12748
				  q{envelopestruct},
12749
				  $tracelevel)
12750
					if defined $::RD_TRACE;
12751
		if (1) { no strict qw{refs};
12752
		$expectation->is(q{messageid})->at($text);
12753
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::messageid($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12754
		{
12755
 
12756
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [messageid]>>},
12757
						  Parse::RecDescent::_tracefirst($text),
12758
						  q{envelopestruct},
12759
						  $tracelevel)
12760
							if defined $::RD_TRACE;
12761
			$expectation->failed();
12762
			last;
12763
		}
12764
		Parse::RecDescent::_trace(q{>>Matched subrule: [messageid]<< (return value: [}
12765
					. $_tok . q{]},
12766
 
12767
					  Parse::RecDescent::_tracefirst($text),
12768
					  q{envelopestruct},
12769
					  $tracelevel)
12770
						if defined $::RD_TRACE;
12771
		$item{q{messageid}} = $_tok;
12772
		push @item, $_tok;
12773
 
12774
		}
12775
 
12776
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
12777
					  Parse::RecDescent::_tracefirst($text),
12778
					  q{envelopestruct},
12779
					  $tracelevel)
12780
						if defined $::RD_TRACE;
12781
		$lastsep = "";
12782
		$expectation->is(q{')'})->at($text);
12783
 
12784
 
12785
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
12786
		     substr($text,0,length($_tok)) eq $_tok and
12787
		     do { substr($text,0,length($_tok)) = ""; 1; }
12788
		)
12789
		{
12790
 
12791
			$expectation->failed();
12792
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
12793
						  Parse::RecDescent::_tracefirst($text))
12794
							if defined $::RD_TRACE;
12795
			last;
12796
		}
12797
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
12798
						. $_tok . q{])},
12799
						  Parse::RecDescent::_tracefirst($text))
12800
							if defined $::RD_TRACE;
12801
		push @item, $item{__STRING2__}=$_tok;
12802
 
12803
 
12804
		Parse::RecDescent::_trace(q{Trying action},
12805
					  Parse::RecDescent::_tracefirst($text),
12806
					  q{envelopestruct},
12807
					  $tracelevel)
12808
						if defined $::RD_TRACE;
12809
 
12810
 
12811
		$_tok = ($_noactions) ? 0 : do { $return = {}; 
12812
	  foreach my $what (qw/date subject from sender replyto to cc bcc inreplyto messageid/) {
12813
		$return->{$what} = $item{$what};
12814
	  }
12815
	  bless $return, "Mail::IMAPClient::BodyStructure::Envelope";
12816
	  $return||defined($return);
12817
	};
12818
		unless (defined $_tok)
12819
		{
12820
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
12821
					if defined $::RD_TRACE;
12822
			last;
12823
		}
12824
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
12825
					  . $_tok . q{])},
12826
					  Parse::RecDescent::_tracefirst($text))
12827
						if defined $::RD_TRACE;
12828
		push @item, $_tok;
12829
		$item{__ACTION1__}=$_tok;
12830
 
12831
 
12832
 
12833
		Parse::RecDescent::_trace(q{>>Matched production: ['(' date subject from sender replyto to cc bcc inreplyto messageid ')']<<},
12834
					  Parse::RecDescent::_tracefirst($text),
12835
					  q{envelopestruct},
12836
					  $tracelevel)
12837
						if defined $::RD_TRACE;
12838
		$_matched = 1;
12839
		last;
12840
	}
12841
 
12842
		splice
12843
				@{$thisparser->{deferred}}, $def_at unless $_matched;
12844
 
12845
        unless ( $_matched || defined($score) )
12846
	{
12847
				splice @{$thisparser->{deferred}}, $def_at;
12848
 
12849
 
12850
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
12851
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
12852
					 Parse::RecDescent::_tracefirst($_[1]),
12853
					 q{envelopestruct},
12854
					 $tracelevel)
12855
					if defined $::RD_TRACE;
12856
		return undef;
12857
	}
12858
	if (!defined($return) && defined($score))
12859
	{
12860
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
12861
					  q{envelopestruct},
12862
					  $tracelevel)
12863
						if defined $::RD_TRACE;
12864
		$return = $score_return;
12865
	}
12866
	splice @{$thisparser->{errors}}, $err_at;
12867
	$return = $item[$#item] unless defined $return;
12868
	if (defined $::RD_TRACE)
12869
	{
12870
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
12871
					  $return . q{])}, "",
12872
					  q{envelopestruct},
12873
					  $tracelevel);
12874
		Parse::RecDescent::_trace(q{(consumed: [} .
12875
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
12876
					  Parse::RecDescent::_tracefirst($text),
12877
					  , q{envelopestruct},
12878
					  $tracelevel)
12879
	}
12880
	$_[1] = $text;
12881
	return $return;
12882
}
12883
 
12884
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
12885
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::replyto
12886
{
12887
	my $thisparser = $_[0];
12888
	use vars q{$tracelevel};
12889
	local $tracelevel = ($tracelevel||0)+1;
12890
	$ERRORS = 0;
12891
	my $thisrule = $thisparser->{"rules"}{"replyto"};
12892
 
12893
	Parse::RecDescent::_trace(q{Trying rule: [replyto]},
12894
				  Parse::RecDescent::_tracefirst($_[1]),
12895
				  q{replyto},
12896
				  $tracelevel)
12897
					if defined $::RD_TRACE;
12898
 
12899
	my $def_at = @{$thisparser->{deferred}};
12900
	my $err_at = @{$thisparser->{errors}};
12901
 
12902
	my $score;
12903
	my $score_return;
12904
	my $_tok;
12905
	my $return = undef;
12906
	my $_matched=0;
12907
	my $commit=0;
12908
	my @item = ();
12909
	my %item = ();
12910
	my $repeating =  defined($_[2]) && $_[2];
12911
	my $_noactions = defined($_[3]) && $_[3];
12912
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
12913
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
12914
	my $text;
12915
	my $lastsep="";
12916
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or '('});
12917
	$expectation->at($_[1]);
12918
 
12919
	my $thisline;
12920
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
12921
 
12922
 
12923
 
12924
	while (!$_matched && !$commit)
12925
	{
12926
 
12927
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
12928
					  Parse::RecDescent::_tracefirst($_[1]),
12929
					  q{replyto},
12930
					  $tracelevel)
12931
						if defined $::RD_TRACE;
12932
		my $thisprod = $thisrule->{"prods"}[0];
12933
		$text = $_[1];
12934
		my $_savetext;
12935
		@item = (q{replyto});
12936
		%item = (__RULE__ => q{replyto});
12937
		my $repcount = 0;
12938
 
12939
 
12940
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
12941
				  Parse::RecDescent::_tracefirst($text),
12942
				  q{replyto},
12943
				  $tracelevel)
12944
					if defined $::RD_TRACE;
12945
		if (1) { no strict qw{refs};
12946
		$expectation->is(q{})->at($text);
12947
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
12948
		{
12949
 
12950
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
12951
						  Parse::RecDescent::_tracefirst($text),
12952
						  q{replyto},
12953
						  $tracelevel)
12954
							if defined $::RD_TRACE;
12955
			$expectation->failed();
12956
			last;
12957
		}
12958
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
12959
					. $_tok . q{]},
12960
 
12961
					  Parse::RecDescent::_tracefirst($text),
12962
					  q{replyto},
12963
					  $tracelevel)
12964
						if defined $::RD_TRACE;
12965
		$item{q{NIL}} = $_tok;
12966
		push @item, $_tok;
12967
 
12968
		}
12969
 
12970
 
12971
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
12972
					  Parse::RecDescent::_tracefirst($text),
12973
					  q{replyto},
12974
					  $tracelevel)
12975
						if defined $::RD_TRACE;
12976
		$_matched = 1;
12977
		last;
12978
	}
12979
 
12980
		splice
12981
				@{$thisparser->{deferred}}, $def_at unless $_matched;
12982
 
12983
	while (!$_matched && !$commit)
12984
	{
12985
 
12986
		Parse::RecDescent::_trace(q{Trying production: ['(' addressstruct ')']},
12987
					  Parse::RecDescent::_tracefirst($_[1]),
12988
					  q{replyto},
12989
					  $tracelevel)
12990
						if defined $::RD_TRACE;
12991
		my $thisprod = $thisrule->{"prods"}[1];
12992
		$text = $_[1];
12993
		my $_savetext;
12994
		@item = (q{replyto});
12995
		%item = (__RULE__ => q{replyto});
12996
		my $repcount = 0;
12997
 
12998
 
12999
		Parse::RecDescent::_trace(q{Trying terminal: ['(']},
13000
					  Parse::RecDescent::_tracefirst($text),
13001
					  q{replyto},
13002
					  $tracelevel)
13003
						if defined $::RD_TRACE;
13004
		$lastsep = "";
13005
		$expectation->is(q{})->at($text);
13006
 
13007
 
13008
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = "("; 1 } and
13009
		     substr($text,0,length($_tok)) eq $_tok and
13010
		     do { substr($text,0,length($_tok)) = ""; 1; }
13011
		)
13012
		{
13013
 
13014
			$expectation->failed();
13015
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
13016
						  Parse::RecDescent::_tracefirst($text))
13017
							if defined $::RD_TRACE;
13018
			last;
13019
		}
13020
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
13021
						. $_tok . q{])},
13022
						  Parse::RecDescent::_tracefirst($text))
13023
							if defined $::RD_TRACE;
13024
		push @item, $item{__STRING1__}=$_tok;
13025
 
13026
 
13027
		Parse::RecDescent::_trace(q{Trying repeated subrule: [addressstruct]},
13028
				  Parse::RecDescent::_tracefirst($text),
13029
				  q{replyto},
13030
				  $tracelevel)
13031
					if defined $::RD_TRACE;
13032
		$expectation->is(q{addressstruct})->at($text);
13033
 
13034
		unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::addressstruct, 1, 100000000, $_noactions,$expectation,sub { \@arg }))) 
13035
		{
13036
			Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [addressstruct]>>},
13037
						  Parse::RecDescent::_tracefirst($text),
13038
						  q{replyto},
13039
						  $tracelevel)
13040
							if defined $::RD_TRACE;
13041
			last;
13042
		}
13043
		Parse::RecDescent::_trace(q{>>Matched repeated subrule: [addressstruct]<< (}
13044
					. @$_tok . q{ times)},
13045
 
13046
					  Parse::RecDescent::_tracefirst($text),
13047
					  q{replyto},
13048
					  $tracelevel)
13049
						if defined $::RD_TRACE;
13050
		$item{q{addressstruct(s)}} = $_tok;
13051
		push @item, $_tok;
13052
 
13053
 
13054
 
13055
		Parse::RecDescent::_trace(q{Trying terminal: [')']},
13056
					  Parse::RecDescent::_tracefirst($text),
13057
					  q{replyto},
13058
					  $tracelevel)
13059
						if defined $::RD_TRACE;
13060
		$lastsep = "";
13061
		$expectation->is(q{')'})->at($text);
13062
 
13063
 
13064
		unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   do { $_tok = ")"; 1 } and
13065
		     substr($text,0,length($_tok)) eq $_tok and
13066
		     do { substr($text,0,length($_tok)) = ""; 1; }
13067
		)
13068
		{
13069
 
13070
			$expectation->failed();
13071
			Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
13072
						  Parse::RecDescent::_tracefirst($text))
13073
							if defined $::RD_TRACE;
13074
			last;
13075
		}
13076
		Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
13077
						. $_tok . q{])},
13078
						  Parse::RecDescent::_tracefirst($text))
13079
							if defined $::RD_TRACE;
13080
		push @item, $item{__STRING2__}=$_tok;
13081
 
13082
 
13083
		Parse::RecDescent::_trace(q{Trying action},
13084
					  Parse::RecDescent::_tracefirst($text),
13085
					  q{replyto},
13086
					  $tracelevel)
13087
						if defined $::RD_TRACE;
13088
 
13089
 
13090
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{'addressstruct(s)'} };
13091
		unless (defined $_tok)
13092
		{
13093
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
13094
					if defined $::RD_TRACE;
13095
			last;
13096
		}
13097
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
13098
					  . $_tok . q{])},
13099
					  Parse::RecDescent::_tracefirst($text))
13100
						if defined $::RD_TRACE;
13101
		push @item, $_tok;
13102
		$item{__ACTION1__}=$_tok;
13103
 
13104
 
13105
 
13106
		Parse::RecDescent::_trace(q{>>Matched production: ['(' addressstruct ')']<<},
13107
					  Parse::RecDescent::_tracefirst($text),
13108
					  q{replyto},
13109
					  $tracelevel)
13110
						if defined $::RD_TRACE;
13111
		$_matched = 1;
13112
		last;
13113
	}
13114
 
13115
		splice
13116
				@{$thisparser->{deferred}}, $def_at unless $_matched;
13117
 
13118
        unless ( $_matched || defined($score) )
13119
	{
13120
				splice @{$thisparser->{deferred}}, $def_at;
13121
 
13122
 
13123
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
13124
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
13125
					 Parse::RecDescent::_tracefirst($_[1]),
13126
					 q{replyto},
13127
					 $tracelevel)
13128
					if defined $::RD_TRACE;
13129
		return undef;
13130
	}
13131
	if (!defined($return) && defined($score))
13132
	{
13133
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
13134
					  q{replyto},
13135
					  $tracelevel)
13136
						if defined $::RD_TRACE;
13137
		$return = $score_return;
13138
	}
13139
	splice @{$thisparser->{errors}}, $err_at;
13140
	$return = $item[$#item] unless defined $return;
13141
	if (defined $::RD_TRACE)
13142
	{
13143
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
13144
					  $return . q{])}, "",
13145
					  q{replyto},
13146
					  $tracelevel);
13147
		Parse::RecDescent::_trace(q{(consumed: [} .
13148
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
13149
					  Parse::RecDescent::_tracefirst($text),
13150
					  , q{replyto},
13151
					  $tracelevel)
13152
	}
13153
	$_[1] = $text;
13154
	return $return;
13155
}
13156
 
13157
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
13158
sub Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::mailboxname
13159
{
13160
	my $thisparser = $_[0];
13161
	use vars q{$tracelevel};
13162
	local $tracelevel = ($tracelevel||0)+1;
13163
	$ERRORS = 0;
13164
	my $thisrule = $thisparser->{"rules"}{"mailboxname"};
13165
 
13166
	Parse::RecDescent::_trace(q{Trying rule: [mailboxname]},
13167
				  Parse::RecDescent::_tracefirst($_[1]),
13168
				  q{mailboxname},
13169
				  $tracelevel)
13170
					if defined $::RD_TRACE;
13171
 
13172
	my $def_at = @{$thisparser->{deferred}};
13173
	my $err_at = @{$thisparser->{errors}};
13174
 
13175
	my $score;
13176
	my $score_return;
13177
	my $_tok;
13178
	my $return = undef;
13179
	my $_matched=0;
13180
	my $commit=0;
13181
	my @item = ();
13182
	my %item = ();
13183
	my $repeating =  defined($_[2]) && $_[2];
13184
	my $_noactions = defined($_[3]) && $_[3];
13185
 	my @arg =        defined $_[4] ? @{ &{$_[4]} } : ();
13186
	my %arg =        ($#arg & 01) ? @arg : (@arg, undef);
13187
	my $text;
13188
	my $lastsep="";
13189
    my $expectation = new Parse::RecDescent::Expectation(q{NIL, or STRING});
13190
	$expectation->at($_[1]);
13191
 
13192
	my $thisline;
13193
	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
13194
 
13195
 
13196
 
13197
	while (!$_matched && !$commit)
13198
	{
13199
 
13200
		Parse::RecDescent::_trace(q{Trying production: [NIL]},
13201
					  Parse::RecDescent::_tracefirst($_[1]),
13202
					  q{mailboxname},
13203
					  $tracelevel)
13204
						if defined $::RD_TRACE;
13205
		my $thisprod = $thisrule->{"prods"}[0];
13206
		$text = $_[1];
13207
		my $_savetext;
13208
		@item = (q{mailboxname});
13209
		%item = (__RULE__ => q{mailboxname});
13210
		my $repcount = 0;
13211
 
13212
 
13213
		Parse::RecDescent::_trace(q{Trying subrule: [NIL]},
13214
				  Parse::RecDescent::_tracefirst($text),
13215
				  q{mailboxname},
13216
				  $tracelevel)
13217
					if defined $::RD_TRACE;
13218
		if (1) { no strict qw{refs};
13219
		$expectation->is(q{})->at($text);
13220
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::NIL($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
13221
		{
13222
 
13223
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [NIL]>>},
13224
						  Parse::RecDescent::_tracefirst($text),
13225
						  q{mailboxname},
13226
						  $tracelevel)
13227
							if defined $::RD_TRACE;
13228
			$expectation->failed();
13229
			last;
13230
		}
13231
		Parse::RecDescent::_trace(q{>>Matched subrule: [NIL]<< (return value: [}
13232
					. $_tok . q{]},
13233
 
13234
					  Parse::RecDescent::_tracefirst($text),
13235
					  q{mailboxname},
13236
					  $tracelevel)
13237
						if defined $::RD_TRACE;
13238
		$item{q{NIL}} = $_tok;
13239
		push @item, $_tok;
13240
 
13241
		}
13242
 
13243
 
13244
		Parse::RecDescent::_trace(q{>>Matched production: [NIL]<<},
13245
					  Parse::RecDescent::_tracefirst($text),
13246
					  q{mailboxname},
13247
					  $tracelevel)
13248
						if defined $::RD_TRACE;
13249
		$_matched = 1;
13250
		last;
13251
	}
13252
 
13253
		splice
13254
				@{$thisparser->{deferred}}, $def_at unless $_matched;
13255
 
13256
	while (!$_matched && !$commit)
13257
	{
13258
 
13259
		Parse::RecDescent::_trace(q{Trying production: [STRING]},
13260
					  Parse::RecDescent::_tracefirst($_[1]),
13261
					  q{mailboxname},
13262
					  $tracelevel)
13263
						if defined $::RD_TRACE;
13264
		my $thisprod = $thisrule->{"prods"}[1];
13265
		$text = $_[1];
13266
		my $_savetext;
13267
		@item = (q{mailboxname});
13268
		%item = (__RULE__ => q{mailboxname});
13269
		my $repcount = 0;
13270
 
13271
 
13272
		Parse::RecDescent::_trace(q{Trying subrule: [STRING]},
13273
				  Parse::RecDescent::_tracefirst($text),
13274
				  q{mailboxname},
13275
				  $tracelevel)
13276
					if defined $::RD_TRACE;
13277
		if (1) { no strict qw{refs};
13278
		$expectation->is(q{})->at($text);
13279
		unless (defined ($_tok = Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse::STRING($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
13280
		{
13281
 
13282
			Parse::RecDescent::_trace(q{<<Didn't match subrule: [STRING]>>},
13283
						  Parse::RecDescent::_tracefirst($text),
13284
						  q{mailboxname},
13285
						  $tracelevel)
13286
							if defined $::RD_TRACE;
13287
			$expectation->failed();
13288
			last;
13289
		}
13290
		Parse::RecDescent::_trace(q{>>Matched subrule: [STRING]<< (return value: [}
13291
					. $_tok . q{]},
13292
 
13293
					  Parse::RecDescent::_tracefirst($text),
13294
					  q{mailboxname},
13295
					  $tracelevel)
13296
						if defined $::RD_TRACE;
13297
		$item{q{STRING}} = $_tok;
13298
		push @item, $_tok;
13299
 
13300
		}
13301
 
13302
		Parse::RecDescent::_trace(q{Trying action},
13303
					  Parse::RecDescent::_tracefirst($text),
13304
					  q{mailboxname},
13305
					  $tracelevel)
13306
						if defined $::RD_TRACE;
13307
 
13308
 
13309
		$_tok = ($_noactions) ? 0 : do { $return = $item{NIL} || $item{STRING} ;$return||defined($return);};
13310
		unless (defined $_tok)
13311
		{
13312
			Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
13313
					if defined $::RD_TRACE;
13314
			last;
13315
		}
13316
		Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
13317
					  . $_tok . q{])},
13318
					  Parse::RecDescent::_tracefirst($text))
13319
						if defined $::RD_TRACE;
13320
		push @item, $_tok;
13321
		$item{__ACTION1__}=$_tok;
13322
 
13323
 
13324
 
13325
		Parse::RecDescent::_trace(q{>>Matched production: [STRING]<<},
13326
					  Parse::RecDescent::_tracefirst($text),
13327
					  q{mailboxname},
13328
					  $tracelevel)
13329
						if defined $::RD_TRACE;
13330
		$_matched = 1;
13331
		last;
13332
	}
13333
 
13334
		splice
13335
				@{$thisparser->{deferred}}, $def_at unless $_matched;
13336
 
13337
        unless ( $_matched || defined($score) )
13338
	{
13339
				splice @{$thisparser->{deferred}}, $def_at;
13340
 
13341
 
13342
		$_[1] = $text;	# NOT SURE THIS IS NEEDED
13343
		Parse::RecDescent::_trace(q{<<Didn't match rule>>},
13344
					 Parse::RecDescent::_tracefirst($_[1]),
13345
					 q{mailboxname},
13346
					 $tracelevel)
13347
					if defined $::RD_TRACE;
13348
		return undef;
13349
	}
13350
	if (!defined($return) && defined($score))
13351
	{
13352
		Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
13353
					  q{mailboxname},
13354
					  $tracelevel)
13355
						if defined $::RD_TRACE;
13356
		$return = $score_return;
13357
	}
13358
	splice @{$thisparser->{errors}}, $err_at;
13359
	$return = $item[$#item] unless defined $return;
13360
	if (defined $::RD_TRACE)
13361
	{
13362
		Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
13363
					  $return . q{])}, "",
13364
					  q{mailboxname},
13365
					  $tracelevel);
13366
		Parse::RecDescent::_trace(q{(consumed: [} .
13367
					  Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, 
13368
					  Parse::RecDescent::_tracefirst($text),
13369
					  , q{mailboxname},
13370
					  $tracelevel)
13371
	}
13372
	$_[1] = $text;
13373
	return $return;
13374
}
13375
}
13376
package Mail::IMAPClient::BodyStructure::Parse; sub new { my $self = bless( {
13377
                 '_AUTOTREE' => undef,
13378
                 'localvars' => '',
13379
                 'startcode' => '',
13380
                 '_check' => {
13381
                               'thisoffset' => '',
13382
                               'itempos' => '',
13383
                               'prevoffset' => '',
13384
                               'prevline' => '',
13385
                               'prevcolumn' => '',
13386
                               'thiscolumn' => ''
13387
                             },
13388
                 'namespace' => 'Parse::RecDescent::Mail::IMAPClient::BodyStructure::Parse',
13389
                 'deferrable' => 1,
13390
                 '_AUTOACTION' => undef,
13391
                 'rules' => {
13392
                              'bodyparms' => bless( {
13393
                                                      'impcount' => 0,
13394
                                                      'calls' => [
13395
                                                                   'NIL',
13396
                                                                   'kvpair'
13397
                                                                 ],
13398
                                                      'changed' => 0,
13399
                                                      'opcount' => 0,
13400
                                                      'prods' => [
13401
                                                                   bless( {
13402
                                                                            'number' => '0',
13403
                                                                            'strcount' => 0,
13404
                                                                            'dircount' => 0,
13405
                                                                            'uncommit' => undef,
13406
                                                                            'error' => undef,
13407
                                                                            'patcount' => 0,
13408
                                                                            'actcount' => 0,
13409
                                                                            'items' => [
13410
                                                                                         bless( {
13411
                                                                                                  'subrule' => 'NIL',
13412
                                                                                                  'matchrule' => 0,
13413
                                                                                                  'implicit' => undef,
13414
                                                                                                  'argcode' => undef,
13415
                                                                                                  'lookahead' => 0,
13416
                                                                                                  'line' => 76
13417
                                                                                                }, 'Parse::RecDescent::Subrule' )
13418
                                                                                       ],
13419
                                                                            'line' => undef
13420
                                                                          }, 'Parse::RecDescent::Production' ),
13421
                                                                   bless( {
13422
                                                                            'number' => '1',
13423
                                                                            'strcount' => 2,
13424
                                                                            'dircount' => 0,
13425
                                                                            'uncommit' => undef,
13426
                                                                            'error' => undef,
13427
                                                                            'patcount' => 0,
13428
                                                                            'actcount' => 1,
13429
                                                                            'items' => [
13430
                                                                                         bless( {
13431
                                                                                                  'pattern' => '(',
13432
                                                                                                  'hashname' => '__STRING1__',
13433
                                                                                                  'description' => '\'(\'',
13434
                                                                                                  'lookahead' => 0,
13435
                                                                                                  'line' => 76
13436
                                                                                                }, 'Parse::RecDescent::Literal' ),
13437
                                                                                         bless( {
13438
                                                                                                  'subrule' => 'kvpair',
13439
                                                                                                  'expected' => undef,
13440
                                                                                                  'min' => 1,
13441
                                                                                                  'argcode' => undef,
13442
                                                                                                  'max' => 100000000,
13443
                                                                                                  'matchrule' => 0,
13444
                                                                                                  'repspec' => 's',
13445
                                                                                                  'lookahead' => 0,
13446
                                                                                                  'line' => 76
13447
                                                                                                }, 'Parse::RecDescent::Repetition' ),
13448
                                                                                         bless( {
13449
                                                                                                  'pattern' => ')',
13450
                                                                                                  'hashname' => '__STRING2__',
13451
                                                                                                  'description' => '\')\'',
13452
                                                                                                  'lookahead' => 0,
13453
                                                                                                  'line' => 76
13454
                                                                                                }, 'Parse::RecDescent::Literal' ),
13455
                                                                                         bless( {
13456
                                                                                                  'hashname' => '__ACTION1__',
13457
                                                                                                  'lookahead' => 0,
13458
                                                                                                  'line' => 77,
13459
                                                                                                  'code' => '{
13460
                          $return = $item{NIL} || 
13461
                                    { map { (%$_) } @{$item{\'kvpair(s)\'}} };
13462
                          $return || defined($return); 
13463
                        }'
13464
                                                                                                }, 'Parse::RecDescent::Action' )
13465
                                                                                       ],
13466
                                                                            'line' => 76
13467
                                                                          }, 'Parse::RecDescent::Production' )
13468
                                                                 ],
13469
                                                      'name' => 'bodyparms',
13470
                                                      'vars' => '',
13471
                                                      'line' => 76
13472
                                                    }, 'Parse::RecDescent::Rule' ),
13473
                              'date' => bless( {
13474
                                                 'impcount' => 0,
13475
                                                 'calls' => [
13476
                                                              'NIL',
13477
                                                              'STRING'
13478
                                                            ],
13479
                                                 'changed' => 0,
13480
                                                 'opcount' => 0,
13481
                                                 'prods' => [
13482
                                                              bless( {
13483
                                                                       'number' => '0',
13484
                                                                       'strcount' => 0,
13485
                                                                       'dircount' => 0,
13486
                                                                       'uncommit' => undef,
13487
                                                                       'error' => undef,
13488
                                                                       'patcount' => 0,
13489
                                                                       'actcount' => 0,
13490
                                                                       'items' => [
13491
                                                                                    bless( {
13492
                                                                                             'subrule' => 'NIL',
13493
                                                                                             'matchrule' => 0,
13494
                                                                                             'implicit' => undef,
13495
                                                                                             'argcode' => undef,
13496
                                                                                             'lookahead' => 0,
13497
                                                                                             'line' => 134
13498
                                                                                           }, 'Parse::RecDescent::Subrule' )
13499
                                                                                  ],
13500
                                                                       'line' => undef
13501
                                                                     }, 'Parse::RecDescent::Production' ),
13502
                                                              bless( {
13503
                                                                       'number' => '1',
13504
                                                                       'strcount' => 0,
13505
                                                                       'dircount' => 0,
13506
                                                                       'uncommit' => undef,
13507
                                                                       'error' => undef,
13508
                                                                       'patcount' => 0,
13509
                                                                       'actcount' => 1,
13510
                                                                       'items' => [
13511
                                                                                    bless( {
13512
                                                                                             'subrule' => 'STRING',
13513
                                                                                             'matchrule' => 0,
13514
                                                                                             'implicit' => undef,
13515
                                                                                             'argcode' => undef,
13516
                                                                                             'lookahead' => 0,
13517
                                                                                             'line' => 134
13518
                                                                                           }, 'Parse::RecDescent::Subrule' ),
13519
                                                                                    bless( {
13520
                                                                                             'hashname' => '__ACTION1__',
13521
                                                                                             'lookahead' => 0,
13522
                                                                                             'line' => 135,
13523
                                                                                             'code' => '{ $return = $item{NIL} || $item{STRING} ;$return||defined($return);}'
13524
                                                                                           }, 'Parse::RecDescent::Action' )
13525
                                                                                  ],
13526
                                                                       'line' => 134
13527
                                                                     }, 'Parse::RecDescent::Production' )
13528
                                                            ],
13529
                                                 'name' => 'date',
13530
                                                 'vars' => '',
13531
                                                 'line' => 134
13532
                                               }, 'Parse::RecDescent::Rule' ),
13533
                              'bodysubtype' => bless( {
13534
                                                        'impcount' => 0,
13535
                                                        'calls' => [
13536
                                                                     'PLAIN',
13537
                                                                     'HTML',
13538
                                                                     'NIL',
13539
                                                                     'STRING'
13540
                                                                   ],
13541
                                                        'changed' => 0,
13542
                                                        'opcount' => 0,
13543
                                                        'prods' => [
13544
                                                                     bless( {
13545
                                                                              'number' => '0',
13546
                                                                              'strcount' => 0,
13547
                                                                              'dircount' => 0,
13548
                                                                              'uncommit' => undef,
13549
                                                                              'error' => undef,
13550
                                                                              'patcount' => 0,
13551
                                                                              'actcount' => 0,
13552
                                                                              'items' => [
13553
                                                                                           bless( {
13554
                                                                                                    'subrule' => 'PLAIN',
13555
                                                                                                    'matchrule' => 0,
13556
                                                                                                    'implicit' => undef,
13557
                                                                                                    'argcode' => undef,
13558
                                                                                                    'lookahead' => 0,
13559
                                                                                                    'line' => 72
13560
                                                                                                  }, 'Parse::RecDescent::Subrule' )
13561
                                                                                         ],
13562
                                                                              'line' => undef
13563
                                                                            }, 'Parse::RecDescent::Production' ),
13564
                                                                     bless( {
13565
                                                                              'number' => '1',
13566
                                                                              'strcount' => 0,
13567
                                                                              'dircount' => 0,
13568
                                                                              'uncommit' => undef,
13569
                                                                              'error' => undef,
13570
                                                                              'patcount' => 0,
13571
                                                                              'actcount' => 0,
13572
                                                                              'items' => [
13573
                                                                                           bless( {
13574
                                                                                                    'subrule' => 'HTML',
13575
                                                                                                    'matchrule' => 0,
13576
                                                                                                    'implicit' => undef,
13577
                                                                                                    'argcode' => undef,
13578
                                                                                                    'lookahead' => 0,
13579
                                                                                                    'line' => 72
13580
                                                                                                  }, 'Parse::RecDescent::Subrule' )
13581
                                                                                         ],
13582
                                                                              'line' => 72
13583
                                                                            }, 'Parse::RecDescent::Production' ),
13584
                                                                     bless( {
13585
                                                                              'number' => '2',
13586
                                                                              'strcount' => 0,
13587
                                                                              'dircount' => 0,
13588
                                                                              'uncommit' => undef,
13589
                                                                              'error' => undef,
13590
                                                                              'patcount' => 0,
13591
                                                                              'actcount' => 0,
13592
                                                                              'items' => [
13593
                                                                                           bless( {
13594
                                                                                                    'subrule' => 'NIL',
13595
                                                                                                    'matchrule' => 0,
13596
                                                                                                    'implicit' => undef,
13597
                                                                                                    'argcode' => undef,
13598
                                                                                                    'lookahead' => 0,
13599
                                                                                                    'line' => 72
13600
                                                                                                  }, 'Parse::RecDescent::Subrule' )
13601
                                                                                         ],
13602
                                                                              'line' => 72
13603
                                                                            }, 'Parse::RecDescent::Production' ),
13604
                                                                     bless( {
13605
                                                                              'number' => '3',
13606
                                                                              'strcount' => 0,
13607
                                                                              'dircount' => 0,
13608
                                                                              'uncommit' => undef,
13609
                                                                              'error' => undef,
13610
                                                                              'patcount' => 0,
13611
                                                                              'actcount' => 1,
13612
                                                                              'items' => [
13613
                                                                                           bless( {
13614
                                                                                                    'subrule' => 'STRING',
13615
                                                                                                    'matchrule' => 0,
13616
                                                                                                    'implicit' => undef,
13617
                                                                                                    'argcode' => undef,
13618
                                                                                                    'lookahead' => 0,
13619
                                                                                                    'line' => 72
13620
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
13621
                                                                                           bless( {
13622
                                                                                                    'hashname' => '__ACTION1__',
13623
                                                                                                    'lookahead' => 0,
13624
                                                                                                    'line' => 73,
13625
                                                                                                    'code' => '{ $return = $item{PLAIN}||$item{HTML}||$item{NIL}||$item{STRING} ; 
13626
		  $return||defined($return);
13627
		}'
13628
                                                                                                  }, 'Parse::RecDescent::Action' )
13629
                                                                                         ],
13630
                                                                              'line' => 72
13631
                                                                            }, 'Parse::RecDescent::Production' )
13632
                                                                   ],
13633
                                                        'name' => 'bodysubtype',
13634
                                                        'vars' => '',
13635
                                                        'line' => 72
13636
                                                      }, 'Parse::RecDescent::Rule' ),
13637
                              'hostname' => bless( {
13638
                                                     'impcount' => 0,
13639
                                                     'calls' => [
13640
                                                                  'NIL',
13641
                                                                  'STRING'
13642
                                                                ],
13643
                                                     'changed' => 0,
13644
                                                     'opcount' => 0,
13645
                                                     'prods' => [
13646
                                                                  bless( {
13647
                                                                           'number' => '0',
13648
                                                                           'strcount' => 0,
13649
                                                                           'dircount' => 0,
13650
                                                                           'uncommit' => undef,
13651
                                                                           'error' => undef,
13652
                                                                           'patcount' => 0,
13653
                                                                           'actcount' => 0,
13654
                                                                           'items' => [
13655
                                                                                        bless( {
13656
                                                                                                 'subrule' => 'NIL',
13657
                                                                                                 'matchrule' => 0,
13658
                                                                                                 'implicit' => undef,
13659
                                                                                                 'argcode' => undef,
13660
                                                                                                 'lookahead' => 0,
13661
                                                                                                 'line' => 112
13662
                                                                                               }, 'Parse::RecDescent::Subrule' )
13663
                                                                                      ],
13664
                                                                           'line' => undef
13665
                                                                         }, 'Parse::RecDescent::Production' ),
13666
                                                                  bless( {
13667
                                                                           'number' => '1',
13668
                                                                           'strcount' => 0,
13669
                                                                           'dircount' => 0,
13670
                                                                           'uncommit' => undef,
13671
                                                                           'error' => undef,
13672
                                                                           'patcount' => 0,
13673
                                                                           'actcount' => 1,
13674
                                                                           'items' => [
13675
                                                                                        bless( {
13676
                                                                                                 'subrule' => 'STRING',
13677
                                                                                                 'matchrule' => 0,
13678
                                                                                                 'implicit' => undef,
13679
                                                                                                 'argcode' => undef,
13680
                                                                                                 'lookahead' => 0,
13681
                                                                                                 'line' => 112
13682
                                                                                               }, 'Parse::RecDescent::Subrule' ),
13683
                                                                                        bless( {
13684
                                                                                                 'hashname' => '__ACTION1__',
13685
                                                                                                 'lookahead' => 0,
13686
                                                                                                 'line' => 113,
13687
                                                                                                 'code' => '{ $return = $item{NIL} || $item{STRING} ;$return||defined($return);}'
13688
                                                                                               }, 'Parse::RecDescent::Action' )
13689
                                                                                      ],
13690
                                                                           'line' => 112
13691
                                                                         }, 'Parse::RecDescent::Production' )
13692
                                                                ],
13693
                                                     'name' => 'hostname',
13694
                                                     'vars' => '',
13695
                                                     'line' => 112
13696
                                                   }, 'Parse::RecDescent::Rule' ),
13697
                              'basicfields' => bless( {
13698
                                                        'impcount' => 0,
13699
                                                        'calls' => [
13700
                                                                     'bodysubtype',
13701
                                                                     'bodyparms',
13702
                                                                     'bodyid',
13703
                                                                     'bodydesc',
13704
                                                                     'bodyenc',
13705
                                                                     'bodysize'
13706
                                                                   ],
13707
                                                        'changed' => 0,
13708
                                                        'opcount' => 0,
13709
                                                        'prods' => [
13710
                                                                     bless( {
13711
                                                                              'number' => '0',
13712
                                                                              'strcount' => 0,
13713
                                                                              'dircount' => 0,
13714
                                                                              'uncommit' => undef,
13715
                                                                              'error' => undef,
13716
                                                                              'patcount' => 0,
13717
                                                                              'actcount' => 1,
13718
                                                                              'items' => [
13719
                                                                                           bless( {
13720
                                                                                                    'subrule' => 'bodysubtype',
13721
                                                                                                    'matchrule' => 0,
13722
                                                                                                    'implicit' => undef,
13723
                                                                                                    'argcode' => undef,
13724
                                                                                                    'lookahead' => 0,
13725
                                                                                                    'line' => 164
13726
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
13727
                                                                                           bless( {
13728
                                                                                                    'subrule' => 'bodyparms',
13729
                                                                                                    'matchrule' => 0,
13730
                                                                                                    'implicit' => undef,
13731
                                                                                                    'argcode' => undef,
13732
                                                                                                    'lookahead' => 0,
13733
                                                                                                    'line' => 164
13734
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
13735
                                                                                           bless( {
13736
                                                                                                    'subrule' => 'bodyid',
13737
                                                                                                    'expected' => undef,
13738
                                                                                                    'min' => 0,
13739
                                                                                                    'argcode' => undef,
13740
                                                                                                    'max' => 1,
13741
                                                                                                    'matchrule' => 0,
13742
                                                                                                    'repspec' => '?',
13743
                                                                                                    'lookahead' => 0,
13744
                                                                                                    'line' => 164
13745
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
13746
                                                                                           bless( {
13747
                                                                                                    'subrule' => 'bodydesc',
13748
                                                                                                    'expected' => undef,
13749
                                                                                                    'min' => 0,
13750
                                                                                                    'argcode' => undef,
13751
                                                                                                    'max' => 1,
13752
                                                                                                    'matchrule' => 0,
13753
                                                                                                    'repspec' => '?',
13754
                                                                                                    'lookahead' => 0,
13755
                                                                                                    'line' => 165
13756
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
13757
                                                                                           bless( {
13758
                                                                                                    'subrule' => 'bodyenc',
13759
                                                                                                    'expected' => undef,
13760
                                                                                                    'min' => 0,
13761
                                                                                                    'argcode' => undef,
13762
                                                                                                    'max' => 1,
13763
                                                                                                    'matchrule' => 0,
13764
                                                                                                    'repspec' => '?',
13765
                                                                                                    'lookahead' => 0,
13766
                                                                                                    'line' => 165
13767
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
13768
                                                                                           bless( {
13769
                                                                                                    'subrule' => 'bodysize',
13770
                                                                                                    'expected' => undef,
13771
                                                                                                    'min' => 0,
13772
                                                                                                    'argcode' => undef,
13773
                                                                                                    'max' => 1,
13774
                                                                                                    'matchrule' => 0,
13775
                                                                                                    'repspec' => '?',
13776
                                                                                                    'lookahead' => 0,
13777
                                                                                                    'line' => 166
13778
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
13779
                                                                                           bless( {
13780
                                                                                                    'hashname' => '__ACTION1__',
13781
                                                                                                    'lookahead' => 0,
13782
                                                                                                    'line' => 166,
13783
                                                                                                    'code' => '{ 
13784
 
13785
	$return = { 
13786
		bodysubtype 	=> 	    $item{bodysubtype} ,
13787
 
13788
		bodyparms 	=> 	    $item{bodyparms} ,
13789
 
13790
		bodyid 		=> (ref     $item{\'bodyid(?)\'}	?
13791
					    $item{\'bodyid(?)\'}[0]	:
13792
					    $item{\'bodyid(?)\'} ),
13793
 
13794
		\'bodydesc\' 	=> (ref     $item{\'bodydesc(?)\'}	?
13795
					    $item{\'bodydesc(?)\'}[0]	:
13796
					    $item{\'bodydesc(?)\'} ),
13797
 
13798
		\'bodyenc\' 	=> (ref     $item{\'bodyenc(?)\'}	?
13799
					    $item{\'bodyenc(?)\'}[0]	:
13800
					    $item{\'bodyenc(?)\'} ),
13801
 
13802
		\'bodysize\' 	=> (ref     $item{\'bodysize(?)\'}	?
13803
					    $item{\'bodysize(?)\'}[0]	:
13804
					    $item{\'bodysize(?)\'} ),
13805
	};
13806
	$return;
13807
}'
13808
                                                                                                  }, 'Parse::RecDescent::Action' )
13809
                                                                                         ],
13810
                                                                              'line' => undef
13811
                                                                            }, 'Parse::RecDescent::Production' )
13812
                                                                   ],
13813
                                                        'name' => 'basicfields',
13814
                                                        'vars' => '',
13815
                                                        'line' => 164
13816
                                                      }, 'Parse::RecDescent::Rule' ),
13817
                              'personalname' => bless( {
13818
                                                         'impcount' => 0,
13819
                                                         'calls' => [
13820
                                                                      'NIL',
13821
                                                                      'STRING'
13822
                                                                    ],
13823
                                                         'changed' => 0,
13824
                                                         'opcount' => 0,
13825
                                                         'prods' => [
13826
                                                                      bless( {
13827
                                                                               'number' => '0',
13828
                                                                               'strcount' => 0,
13829
                                                                               'dircount' => 0,
13830
                                                                               'uncommit' => undef,
13831
                                                                               'error' => undef,
13832
                                                                               'patcount' => 0,
13833
                                                                               'actcount' => 0,
13834
                                                                               'items' => [
13835
                                                                                            bless( {
13836
                                                                                                     'subrule' => 'NIL',
13837
                                                                                                     'matchrule' => 0,
13838
                                                                                                     'implicit' => undef,
13839
                                                                                                     'argcode' => undef,
13840
                                                                                                     'lookahead' => 0,
13841
                                                                                                     'line' => 106
13842
                                                                                                   }, 'Parse::RecDescent::Subrule' )
13843
                                                                                          ],
13844
                                                                               'line' => undef
13845
                                                                             }, 'Parse::RecDescent::Production' ),
13846
                                                                      bless( {
13847
                                                                               'number' => '1',
13848
                                                                               'strcount' => 0,
13849
                                                                               'dircount' => 0,
13850
                                                                               'uncommit' => undef,
13851
                                                                               'error' => undef,
13852
                                                                               'patcount' => 0,
13853
                                                                               'actcount' => 1,
13854
                                                                               'items' => [
13855
                                                                                            bless( {
13856
                                                                                                     'subrule' => 'STRING',
13857
                                                                                                     'matchrule' => 0,
13858
                                                                                                     'implicit' => undef,
13859
                                                                                                     'argcode' => undef,
13860
                                                                                                     'lookahead' => 0,
13861
                                                                                                     'line' => 106
13862
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
13863
                                                                                            bless( {
13864
                                                                                                     'hashname' => '__ACTION1__',
13865
                                                                                                     'lookahead' => 0,
13866
                                                                                                     'line' => 107,
13867
                                                                                                     'code' => '{ $return = $item{NIL} || $item{STRING} ;$return||defined($return);}'
13868
                                                                                                   }, 'Parse::RecDescent::Action' )
13869
                                                                                          ],
13870
                                                                               'line' => 106
13871
                                                                             }, 'Parse::RecDescent::Production' )
13872
                                                                    ],
13873
                                                         'name' => 'personalname',
13874
                                                         'vars' => '',
13875
                                                         'line' => 106
13876
                                                       }, 'Parse::RecDescent::Rule' ),
13877
                              'key' => bless( {
13878
                                                'impcount' => 0,
13879
                                                'calls' => [
13880
                                                             'STRING'
13881
                                                           ],
13882
                                                'changed' => 0,
13883
                                                'opcount' => 0,
13884
                                                'prods' => [
13885
                                                             bless( {
13886
                                                                      'number' => '0',
13887
                                                                      'strcount' => 0,
13888
                                                                      'dircount' => 0,
13889
                                                                      'uncommit' => undef,
13890
                                                                      'error' => undef,
13891
                                                                      'patcount' => 0,
13892
                                                                      'actcount' => 1,
13893
                                                                      'items' => [
13894
                                                                                   bless( {
13895
                                                                                            'subrule' => 'STRING',
13896
                                                                                            'matchrule' => 0,
13897
                                                                                            'implicit' => undef,
13898
                                                                                            'argcode' => undef,
13899
                                                                                            'lookahead' => 0,
13900
                                                                                            'line' => 60
13901
                                                                                          }, 'Parse::RecDescent::Subrule' ),
13902
                                                                                   bless( {
13903
                                                                                            'hashname' => '__ACTION1__',
13904
                                                                                            'lookahead' => 0,
13905
                                                                                            'line' => 60,
13906
                                                                                            'code' => '{ $return = $item{STRING} ; $return||defined($return);}'
13907
                                                                                          }, 'Parse::RecDescent::Action' )
13908
                                                                                 ],
13909
                                                                      'line' => undef
13910
                                                                    }, 'Parse::RecDescent::Production' )
13911
                                                           ],
13912
                                                'name' => 'key',
13913
                                                'vars' => '',
13914
                                                'line' => 60
13915
                                              }, 'Parse::RecDescent::Rule' ),
13916
                              'cc' => bless( {
13917
                                               'impcount' => 0,
13918
                                               'calls' => [
13919
                                                            'NIL',
13920
                                                            'addressstruct'
13921
                                                          ],
13922
                                               'changed' => 0,
13923
                                               'opcount' => 0,
13924
                                               'prods' => [
13925
                                                            bless( {
13926
                                                                     'number' => '0',
13927
                                                                     'strcount' => 0,
13928
                                                                     'dircount' => 0,
13929
                                                                     'uncommit' => undef,
13930
                                                                     'error' => undef,
13931
                                                                     'patcount' => 0,
13932
                                                                     'actcount' => 0,
13933
                                                                     'items' => [
13934
                                                                                  bless( {
13935
                                                                                           'subrule' => 'NIL',
13936
                                                                                           'matchrule' => 0,
13937
                                                                                           'implicit' => undef,
13938
                                                                                           'argcode' => undef,
13939
                                                                                           'lookahead' => 0,
13940
                                                                                           'line' => 137
13941
                                                                                         }, 'Parse::RecDescent::Subrule' )
13942
                                                                                ],
13943
                                                                     'line' => undef
13944
                                                                   }, 'Parse::RecDescent::Production' ),
13945
                                                            bless( {
13946
                                                                     'number' => '1',
13947
                                                                     'strcount' => 2,
13948
                                                                     'dircount' => 0,
13949
                                                                     'uncommit' => undef,
13950
                                                                     'error' => undef,
13951
                                                                     'patcount' => 0,
13952
                                                                     'actcount' => 1,
13953
                                                                     'items' => [
13954
                                                                                  bless( {
13955
                                                                                           'pattern' => '(',
13956
                                                                                           'hashname' => '__STRING1__',
13957
                                                                                           'description' => '\'(\'',
13958
                                                                                           'lookahead' => 0,
13959
                                                                                           'line' => 137
13960
                                                                                         }, 'Parse::RecDescent::InterpLit' ),
13961
                                                                                  bless( {
13962
                                                                                           'subrule' => 'addressstruct',
13963
                                                                                           'expected' => undef,
13964
                                                                                           'min' => 1,
13965
                                                                                           'argcode' => undef,
13966
                                                                                           'max' => 100000000,
13967
                                                                                           'matchrule' => 0,
13968
                                                                                           'repspec' => 's',
13969
                                                                                           'lookahead' => 0,
13970
                                                                                           'line' => 137
13971
                                                                                         }, 'Parse::RecDescent::Repetition' ),
13972
                                                                                  bless( {
13973
                                                                                           'pattern' => ')',
13974
                                                                                           'hashname' => '__STRING2__',
13975
                                                                                           'description' => '\')\'',
13976
                                                                                           'lookahead' => 0,
13977
                                                                                           'line' => 137
13978
                                                                                         }, 'Parse::RecDescent::InterpLit' ),
13979
                                                                                  bless( {
13980
                                                                                           'hashname' => '__ACTION1__',
13981
                                                                                           'lookahead' => 0,
13982
                                                                                           'line' => 138,
13983
                                                                                           'code' => '{ $return = $item{NIL} || $item{\'addressstruct(s)\'} }'
13984
                                                                                         }, 'Parse::RecDescent::Action' )
13985
                                                                                ],
13986
                                                                     'line' => 137
13987
                                                                   }, 'Parse::RecDescent::Production' )
13988
                                                          ],
13989
                                               'name' => 'cc',
13990
                                               'vars' => '',
13991
                                               'line' => 137
13992
                                             }, 'Parse::RecDescent::Rule' ),
13993
                              'bodyMD5' => bless( {
13994
                                                    'impcount' => 0,
13995
                                                    'calls' => [
13996
                                                                 'NIL',
13997
                                                                 'STRING'
13998
                                                               ],
13999
                                                    'changed' => 0,
14000
                                                    'opcount' => 0,
14001
                                                    'prods' => [
14002
                                                                 bless( {
14003
                                                                          'number' => '0',
14004
                                                                          'strcount' => 0,
14005
                                                                          'dircount' => 0,
14006
                                                                          'uncommit' => undef,
14007
                                                                          'error' => undef,
14008
                                                                          'patcount' => 0,
14009
                                                                          'actcount' => 0,
14010
                                                                          'items' => [
14011
                                                                                       bless( {
14012
                                                                                                'subrule' => 'NIL',
14013
                                                                                                'matchrule' => 0,
14014
                                                                                                'implicit' => undef,
14015
                                                                                                'argcode' => undef,
14016
                                                                                                'lookahead' => 0,
14017
                                                                                                'line' => 102
14018
                                                                                              }, 'Parse::RecDescent::Subrule' )
14019
                                                                                     ],
14020
                                                                          'line' => undef
14021
                                                                        }, 'Parse::RecDescent::Production' ),
14022
                                                                 bless( {
14023
                                                                          'number' => '1',
14024
                                                                          'strcount' => 0,
14025
                                                                          'dircount' => 0,
14026
                                                                          'uncommit' => undef,
14027
                                                                          'error' => undef,
14028
                                                                          'patcount' => 0,
14029
                                                                          'actcount' => 1,
14030
                                                                          'items' => [
14031
                                                                                       bless( {
14032
                                                                                                'subrule' => 'STRING',
14033
                                                                                                'matchrule' => 0,
14034
                                                                                                'implicit' => undef,
14035
                                                                                                'argcode' => undef,
14036
                                                                                                'lookahead' => 0,
14037
                                                                                                'line' => 102
14038
                                                                                              }, 'Parse::RecDescent::Subrule' ),
14039
                                                                                       bless( {
14040
                                                                                                'hashname' => '__ACTION1__',
14041
                                                                                                'lookahead' => 0,
14042
                                                                                                'line' => 103,
14043
                                                                                                'code' => '{ $return = $item{NIL} || $item{STRING} ;$return||defined($return);}'
14044
                                                                                              }, 'Parse::RecDescent::Action' )
14045
                                                                                     ],
14046
                                                                          'line' => 102
14047
                                                                        }, 'Parse::RecDescent::Production' )
14048
                                                               ],
14049
                                                    'name' => 'bodyMD5',
14050
                                                    'vars' => '',
14051
                                                    'line' => 102
14052
                                                  }, 'Parse::RecDescent::Rule' ),
14053
                              'envelope' => bless( {
14054
                                                     'impcount' => 0,
14055
                                                     'calls' => [
14056
                                                                  'envelopestruct'
14057
                                                                ],
14058
                                                     'changed' => 0,
14059
                                                     'opcount' => 0,
14060
                                                     'prods' => [
14061
                                                                  bless( {
14062
                                                                           'number' => '0',
14063
                                                                           'strcount' => 0,
14064
                                                                           'dircount' => 0,
14065
                                                                           'uncommit' => undef,
14066
                                                                           'error' => undef,
14067
                                                                           'patcount' => 2,
14068
                                                                           'actcount' => 1,
14069
                                                                           'items' => [
14070
                                                                                        bless( {
14071
                                                                                                 'pattern' => '.*\\(.*ENVELOPE',
14072
                                                                                                 'hashname' => '__PATTERN1__',
14073
                                                                                                 'description' => '/.*\\\\(.*ENVELOPE/',
14074
                                                                                                 'lookahead' => 0,
14075
                                                                                                 'rdelim' => '/',
14076
                                                                                                 'line' => 285,
14077
                                                                                                 'mod' => '',
14078
                                                                                                 'ldelim' => '/'
14079
                                                                                               }, 'Parse::RecDescent::Token' ),
14080
                                                                                        bless( {
14081
                                                                                                 'subrule' => 'envelopestruct',
14082
                                                                                                 'matchrule' => 0,
14083
                                                                                                 'implicit' => undef,
14084
                                                                                                 'argcode' => undef,
14085
                                                                                                 'lookahead' => 0,
14086
                                                                                                 'line' => 285
14087
                                                                                               }, 'Parse::RecDescent::Subrule' ),
14088
                                                                                        bless( {
14089
                                                                                                 'pattern' => '.*\\)',
14090
                                                                                                 'hashname' => '__PATTERN2__',
14091
                                                                                                 'description' => '/.*\\\\)/',
14092
                                                                                                 'lookahead' => 0,
14093
                                                                                                 'rdelim' => '/',
14094
                                                                                                 'line' => 285,
14095
                                                                                                 'mod' => '',
14096
                                                                                                 'ldelim' => '/'
14097
                                                                                               }, 'Parse::RecDescent::Token' ),
14098
                                                                                        bless( {
14099
                                                                                                 'hashname' => '__ACTION1__',
14100
                                                                                                 'lookahead' => 0,
14101
                                                                                                 'line' => 285,
14102
                                                                                                 'code' => '{
14103
		$return = $item{envelopestruct} ;
14104
		$return||defined($return) ;
14105
		}'
14106
                                                                                               }, 'Parse::RecDescent::Action' )
14107
                                                                                      ],
14108
                                                                           'line' => undef
14109
                                                                         }, 'Parse::RecDescent::Production' )
14110
                                                                ],
14111
                                                     'name' => 'envelope',
14112
                                                     'vars' => '',
14113
                                                     'line' => 285
14114
                                                   }, 'Parse::RecDescent::Rule' ),
14115
                              'MESSAGE' => bless( {
14116
                                                    'impcount' => 0,
14117
                                                    'calls' => [],
14118
                                                    'changed' => 0,
14119
                                                    'opcount' => 0,
14120
                                                    'prods' => [
14121
                                                                 bless( {
14122
                                                                          'number' => '0',
14123
                                                                          'strcount' => 0,
14124
                                                                          'dircount' => 0,
14125
                                                                          'uncommit' => undef,
14126
                                                                          'error' => undef,
14127
                                                                          'patcount' => 1,
14128
                                                                          'actcount' => 1,
14129
                                                                          'items' => [
14130
                                                                                       bless( {
14131
                                                                                                'pattern' => '^"MESSAGE"|^MESSAGE',
14132
                                                                                                'hashname' => '__PATTERN1__',
14133
                                                                                                'description' => '/^"MESSAGE"|^MESSAGE/i',
14134
                                                                                                'lookahead' => 0,
14135
                                                                                                'rdelim' => '/',
14136
                                                                                                'line' => 15,
14137
                                                                                                'mod' => 'i',
14138
                                                                                                'ldelim' => '/'
14139
                                                                                              }, 'Parse::RecDescent::Token' ),
14140
                                                                                       bless( {
14141
                                                                                                'hashname' => '__ACTION1__',
14142
                                                                                                'lookahead' => 0,
14143
                                                                                                'line' => 15,
14144
                                                                                                'code' => '{ $return = "MESSAGE" 	}'
14145
                                                                                              }, 'Parse::RecDescent::Action' )
14146
                                                                                     ],
14147
                                                                          'line' => undef
14148
                                                                        }, 'Parse::RecDescent::Production' )
14149
                                                               ],
14150
                                                    'name' => 'MESSAGE',
14151
                                                    'vars' => '',
14152
                                                    'line' => 15
14153
                                                  }, 'Parse::RecDescent::Rule' ),
14154
                              'DOUBLE_QUOTED_STRING' => bless( {
14155
                                                                 'impcount' => 0,
14156
                                                                 'calls' => [],
14157
                                                                 'changed' => 0,
14158
                                                                 'opcount' => 0,
14159
                                                                 'prods' => [
14160
                                                                              bless( {
14161
                                                                                       'number' => '0',
14162
                                                                                       'strcount' => 2,
14163
                                                                                       'dircount' => 0,
14164
                                                                                       'uncommit' => undef,
14165
                                                                                       'error' => undef,
14166
                                                                                       'patcount' => 1,
14167
                                                                                       'actcount' => 1,
14168
                                                                                       'items' => [
14169
                                                                                                    bless( {
14170
                                                                                                             'pattern' => '"',
14171
                                                                                                             'hashname' => '__STRING1__',
14172
                                                                                                             'description' => '\'"\'',
14173
                                                                                                             'lookahead' => 0,
14174
                                                                                                             'line' => 28
14175
                                                                                                           }, 'Parse::RecDescent::Literal' ),
14176
                                                                                                    bless( {
14177
                                                                                                             'pattern' => '(?:\\\\"|[^"])*',
14178
                                                                                                             'hashname' => '__PATTERN1__',
14179
                                                                                                             'description' => '/(?:\\\\\\\\"|[^"])*/',
14180
                                                                                                             'lookahead' => 0,
14181
                                                                                                             'rdelim' => '/',
14182
                                                                                                             'line' => 28,
14183
                                                                                                             'mod' => '',
14184
                                                                                                             'ldelim' => '/'
14185
                                                                                                           }, 'Parse::RecDescent::Token' ),
14186
                                                                                                    bless( {
14187
                                                                                                             'pattern' => '"',
14188
                                                                                                             'hashname' => '__STRING2__',
14189
                                                                                                             'description' => '\'"\'',
14190
                                                                                                             'lookahead' => 0,
14191
                                                                                                             'line' => 28
14192
                                                                                                           }, 'Parse::RecDescent::Literal' ),
14193
                                                                                                    bless( {
14194
                                                                                                             'hashname' => '__ACTION1__',
14195
                                                                                                             'lookahead' => 0,
14196
                                                                                                             'line' => 28,
14197
                                                                                                             'code' => '{
14198
 
14199
	 $return = $item{__PATTERN1__} ;
14200
	 $return||defined($return);
14201
}'
14202
                                                                                                           }, 'Parse::RecDescent::Action' )
14203
                                                                                                  ],
14204
                                                                                       'line' => undef
14205
                                                                                     }, 'Parse::RecDescent::Production' )
14206
                                                                            ],
14207
                                                                 'name' => 'DOUBLE_QUOTED_STRING',
14208
                                                                 'vars' => '',
14209
                                                                 'line' => 28
14210
                                                               }, 'Parse::RecDescent::Rule' ),
14211
                              'subject' => bless( {
14212
                                                    'impcount' => 0,
14213
                                                    'calls' => [
14214
                                                                 'NIL',
14215
                                                                 'STRING'
14216
                                                               ],
14217
                                                    'changed' => 0,
14218
                                                    'opcount' => 0,
14219
                                                    'prods' => [
14220
                                                                 bless( {
14221
                                                                          'number' => '0',
14222
                                                                          'strcount' => 0,
14223
                                                                          'dircount' => 0,
14224
                                                                          'uncommit' => undef,
14225
                                                                          'error' => undef,
14226
                                                                          'patcount' => 0,
14227
                                                                          'actcount' => 0,
14228
                                                                          'items' => [
14229
                                                                                       bless( {
14230
                                                                                                'subrule' => 'NIL',
14231
                                                                                                'matchrule' => 0,
14232
                                                                                                'implicit' => undef,
14233
                                                                                                'argcode' => undef,
14234
                                                                                                'lookahead' => 0,
14235
                                                                                                'line' => 123
14236
                                                                                              }, 'Parse::RecDescent::Subrule' )
14237
                                                                                     ],
14238
                                                                          'line' => undef
14239
                                                                        }, 'Parse::RecDescent::Production' ),
14240
                                                                 bless( {
14241
                                                                          'number' => '1',
14242
                                                                          'strcount' => 0,
14243
                                                                          'dircount' => 0,
14244
                                                                          'uncommit' => undef,
14245
                                                                          'error' => undef,
14246
                                                                          'patcount' => 0,
14247
                                                                          'actcount' => 1,
14248
                                                                          'items' => [
14249
                                                                                       bless( {
14250
                                                                                                'subrule' => 'STRING',
14251
                                                                                                'matchrule' => 0,
14252
                                                                                                'implicit' => undef,
14253
                                                                                                'argcode' => undef,
14254
                                                                                                'lookahead' => 0,
14255
                                                                                                'line' => 123
14256
                                                                                              }, 'Parse::RecDescent::Subrule' ),
14257
                                                                                       bless( {
14258
                                                                                                'hashname' => '__ACTION1__',
14259
                                                                                                'lookahead' => 0,
14260
                                                                                                'line' => 124,
14261
                                                                                                'code' => '{ 
14262
			$return = $item{NIL} || $item{STRING} ;
14263
			$return||defined($return);
14264
		}'
14265
                                                                                              }, 'Parse::RecDescent::Action' )
14266
                                                                                     ],
14267
                                                                          'line' => 123
14268
                                                                        }, 'Parse::RecDescent::Production' )
14269
                                                               ],
14270
                                                    'name' => 'subject',
14271
                                                    'vars' => '',
14272
                                                    'line' => 123
14273
                                                  }, 'Parse::RecDescent::Rule' ),
14274
                              'value' => bless( {
14275
                                                  'impcount' => 0,
14276
                                                  'calls' => [
14277
                                                               'NIL',
14278
                                                               'kvpair',
14279
                                                               'NUMBER',
14280
                                                               'STRING'
14281
                                                             ],
14282
                                                  'changed' => 0,
14283
                                                  'opcount' => 0,
14284
                                                  'prods' => [
14285
                                                               bless( {
14286
                                                                        'number' => '0',
14287
                                                                        'strcount' => 0,
14288
                                                                        'dircount' => 0,
14289
                                                                        'uncommit' => undef,
14290
                                                                        'error' => undef,
14291
                                                                        'patcount' => 0,
14292
                                                                        'actcount' => 0,
14293
                                                                        'items' => [
14294
                                                                                     bless( {
14295
                                                                                              'subrule' => 'NIL',
14296
                                                                                              'matchrule' => 0,
14297
                                                                                              'implicit' => undef,
14298
                                                                                              'argcode' => undef,
14299
                                                                                              'lookahead' => 0,
14300
                                                                                              'line' => 61
14301
                                                                                            }, 'Parse::RecDescent::Subrule' )
14302
                                                                                   ],
14303
                                                                        'line' => undef
14304
                                                                      }, 'Parse::RecDescent::Production' ),
14305
                                                               bless( {
14306
                                                                        'number' => '1',
14307
                                                                        'strcount' => 2,
14308
                                                                        'dircount' => 1,
14309
                                                                        'uncommit' => undef,
14310
                                                                        'error' => undef,
14311
                                                                        'patcount' => 0,
14312
                                                                        'actcount' => 0,
14313
                                                                        'items' => [
14314
                                                                                     bless( {
14315
                                                                                              'pattern' => '(',
14316
                                                                                              'hashname' => '__STRING1__',
14317
                                                                                              'description' => '\'(\'',
14318
                                                                                              'lookahead' => 0,
14319
                                                                                              'line' => 61
14320
                                                                                            }, 'Parse::RecDescent::Literal' ),
14321
                                                                                     bless( {
14322
                                                                                              'hashname' => '__DIRECTIVE1__',
14323
                                                                                              'name' => '<commit>',
14324
                                                                                              'lookahead' => 0,
14325
                                                                                              'line' => 61,
14326
                                                                                              'code' => '$commit = 1'
14327
                                                                                            }, 'Parse::RecDescent::Directive' ),
14328
                                                                                     bless( {
14329
                                                                                              'subrule' => 'kvpair',
14330
                                                                                              'expected' => undef,
14331
                                                                                              'min' => 1,
14332
                                                                                              'argcode' => undef,
14333
                                                                                              'max' => 100000000,
14334
                                                                                              'matchrule' => 0,
14335
                                                                                              'repspec' => 's',
14336
                                                                                              'lookahead' => 0,
14337
                                                                                              'line' => 61
14338
                                                                                            }, 'Parse::RecDescent::Repetition' ),
14339
                                                                                     bless( {
14340
                                                                                              'pattern' => ')',
14341
                                                                                              'hashname' => '__STRING2__',
14342
                                                                                              'description' => '\')\'',
14343
                                                                                              'lookahead' => 0,
14344
                                                                                              'line' => 61
14345
                                                                                            }, 'Parse::RecDescent::Literal' )
14346
                                                                                   ],
14347
                                                                        'line' => 61
14348
                                                                      }, 'Parse::RecDescent::Production' ),
14349
                                                               bless( {
14350
                                                                        'number' => '2',
14351
                                                                        'strcount' => 0,
14352
                                                                        'dircount' => 0,
14353
                                                                        'uncommit' => undef,
14354
                                                                        'error' => undef,
14355
                                                                        'patcount' => 0,
14356
                                                                        'actcount' => 0,
14357
                                                                        'items' => [
14358
                                                                                     bless( {
14359
                                                                                              'subrule' => 'NUMBER',
14360
                                                                                              'matchrule' => 0,
14361
                                                                                              'implicit' => undef,
14362
                                                                                              'argcode' => undef,
14363
                                                                                              'lookahead' => 0,
14364
                                                                                              'line' => 61
14365
                                                                                            }, 'Parse::RecDescent::Subrule' )
14366
                                                                                   ],
14367
                                                                        'line' => 61
14368
                                                                      }, 'Parse::RecDescent::Production' ),
14369
                                                               bless( {
14370
                                                                        'number' => '3',
14371
                                                                        'strcount' => 0,
14372
                                                                        'dircount' => 0,
14373
                                                                        'uncommit' => undef,
14374
                                                                        'error' => undef,
14375
                                                                        'patcount' => 0,
14376
                                                                        'actcount' => 1,
14377
                                                                        'items' => [
14378
                                                                                     bless( {
14379
                                                                                              'subrule' => 'STRING',
14380
                                                                                              'matchrule' => 0,
14381
                                                                                              'implicit' => undef,
14382
                                                                                              'argcode' => undef,
14383
                                                                                              'lookahead' => 0,
14384
                                                                                              'line' => 61
14385
                                                                                            }, 'Parse::RecDescent::Subrule' ),
14386
                                                                                     bless( {
14387
                                                                                              'hashname' => '__ACTION1__',
14388
                                                                                              'lookahead' => 0,
14389
                                                                                              'line' => 62,
14390
                                                                                              'code' => '{ 	$return = $item{NIL} 		|| 
14391
			$item{NUMBER} 			|| 
14392
			$item{STRING} 			|| 
14393
			{ map { (%$_) } @{$item{\'kvpair(s)\'}} } ;
14394
			$return||defined($return);
14395
		}'
14396
                                                                                            }, 'Parse::RecDescent::Action' )
14397
                                                                                   ],
14398
                                                                        'line' => 61
14399
                                                                      }, 'Parse::RecDescent::Production' )
14400
                                                             ],
14401
                                                  'name' => 'value',
14402
                                                  'vars' => '',
14403
                                                  'line' => 61
14404
                                                }, 'Parse::RecDescent::Rule' ),
14405
                              'inreplyto' => bless( {
14406
                                                      'impcount' => 0,
14407
                                                      'calls' => [
14408
                                                                   'NIL',
14409
                                                                   'STRING'
14410
                                                                 ],
14411
                                                      'changed' => 0,
14412
                                                      'opcount' => 0,
14413
                                                      'prods' => [
14414
                                                                   bless( {
14415
                                                                            'number' => '0',
14416
                                                                            'strcount' => 0,
14417
                                                                            'dircount' => 0,
14418
                                                                            'uncommit' => undef,
14419
                                                                            'error' => undef,
14420
                                                                            'patcount' => 0,
14421
                                                                            'actcount' => 0,
14422
                                                                            'items' => [
14423
                                                                                         bless( {
14424
                                                                                                  'subrule' => 'NIL',
14425
                                                                                                  'matchrule' => 0,
14426
                                                                                                  'implicit' => undef,
14427
                                                                                                  'argcode' => undef,
14428
                                                                                                  'lookahead' => 0,
14429
                                                                                                  'line' => 128
14430
                                                                                                }, 'Parse::RecDescent::Subrule' )
14431
                                                                                       ],
14432
                                                                            'line' => undef
14433
                                                                          }, 'Parse::RecDescent::Production' ),
14434
                                                                   bless( {
14435
                                                                            'number' => '1',
14436
                                                                            'strcount' => 0,
14437
                                                                            'dircount' => 0,
14438
                                                                            'uncommit' => undef,
14439
                                                                            'error' => undef,
14440
                                                                            'patcount' => 0,
14441
                                                                            'actcount' => 1,
14442
                                                                            'items' => [
14443
                                                                                         bless( {
14444
                                                                                                  'subrule' => 'STRING',
14445
                                                                                                  'matchrule' => 0,
14446
                                                                                                  'implicit' => undef,
14447
                                                                                                  'argcode' => undef,
14448
                                                                                                  'lookahead' => 0,
14449
                                                                                                  'line' => 128
14450
                                                                                                }, 'Parse::RecDescent::Subrule' ),
14451
                                                                                         bless( {
14452
                                                                                                  'hashname' => '__ACTION1__',
14453
                                                                                                  'lookahead' => 0,
14454
                                                                                                  'line' => 129,
14455
                                                                                                  'code' => '{ $return = $item{NIL} || $item{STRING} ;$return||defined($return);}'
14456
                                                                                                }, 'Parse::RecDescent::Action' )
14457
                                                                                       ],
14458
                                                                            'line' => 128
14459
                                                                          }, 'Parse::RecDescent::Production' )
14460
                                                                 ],
14461
                                                      'name' => 'inreplyto',
14462
                                                      'vars' => '',
14463
                                                      'line' => 128
14464
                                                    }, 'Parse::RecDescent::Rule' ),
14465
                              'messageid' => bless( {
14466
                                                      'impcount' => 0,
14467
                                                      'calls' => [
14468
                                                                   'NIL',
14469
                                                                   'STRING'
14470
                                                                 ],
14471
                                                      'changed' => 0,
14472
                                                      'opcount' => 0,
14473
                                                      'prods' => [
14474
                                                                   bless( {
14475
                                                                            'number' => '0',
14476
                                                                            'strcount' => 0,
14477
                                                                            'dircount' => 0,
14478
                                                                            'uncommit' => undef,
14479
                                                                            'error' => undef,
14480
                                                                            'patcount' => 0,
14481
                                                                            'actcount' => 0,
14482
                                                                            'items' => [
14483
                                                                                         bless( {
14484
                                                                                                  'subrule' => 'NIL',
14485
                                                                                                  'matchrule' => 0,
14486
                                                                                                  'implicit' => undef,
14487
                                                                                                  'argcode' => undef,
14488
                                                                                                  'lookahead' => 0,
14489
                                                                                                  'line' => 131
14490
                                                                                                }, 'Parse::RecDescent::Subrule' )
14491
                                                                                       ],
14492
                                                                            'line' => undef
14493
                                                                          }, 'Parse::RecDescent::Production' ),
14494
                                                                   bless( {
14495
                                                                            'number' => '1',
14496
                                                                            'strcount' => 0,
14497
                                                                            'dircount' => 0,
14498
                                                                            'uncommit' => undef,
14499
                                                                            'error' => undef,
14500
                                                                            'patcount' => 0,
14501
                                                                            'actcount' => 1,
14502
                                                                            'items' => [
14503
                                                                                         bless( {
14504
                                                                                                  'subrule' => 'STRING',
14505
                                                                                                  'matchrule' => 0,
14506
                                                                                                  'implicit' => undef,
14507
                                                                                                  'argcode' => undef,
14508
                                                                                                  'lookahead' => 0,
14509
                                                                                                  'line' => 131
14510
                                                                                                }, 'Parse::RecDescent::Subrule' ),
14511
                                                                                         bless( {
14512
                                                                                                  'hashname' => '__ACTION1__',
14513
                                                                                                  'lookahead' => 0,
14514
                                                                                                  'line' => 132,
14515
                                                                                                  'code' => '{ $return = $item{NIL} || $item{STRING} ;$return||defined($return);}'
14516
                                                                                                }, 'Parse::RecDescent::Action' )
14517
                                                                                       ],
14518
                                                                            'line' => 131
14519
                                                                          }, 'Parse::RecDescent::Production' )
14520
                                                                 ],
14521
                                                      'name' => 'messageid',
14522
                                                      'vars' => '',
14523
                                                      'line' => 131
14524
                                                    }, 'Parse::RecDescent::Rule' ),
14525
                              'sender' => bless( {
14526
                                                   'impcount' => 0,
14527
                                                   'calls' => [
14528
                                                                'NIL',
14529
                                                                'addressstruct'
14530
                                                              ],
14531
                                                   'changed' => 0,
14532
                                                   'opcount' => 0,
14533
                                                   'prods' => [
14534
                                                                bless( {
14535
                                                                         'number' => '0',
14536
                                                                         'strcount' => 0,
14537
                                                                         'dircount' => 0,
14538
                                                                         'uncommit' => undef,
14539
                                                                         'error' => undef,
14540
                                                                         'patcount' => 0,
14541
                                                                         'actcount' => 0,
14542
                                                                         'items' => [
14543
                                                                                      bless( {
14544
                                                                                               'subrule' => 'NIL',
14545
                                                                                               'matchrule' => 0,
14546
                                                                                               'implicit' => undef,
14547
                                                                                               'argcode' => undef,
14548
                                                                                               'lookahead' => 0,
14549
                                                                                               'line' => 149
14550
                                                                                             }, 'Parse::RecDescent::Subrule' )
14551
                                                                                    ],
14552
                                                                         'line' => undef
14553
                                                                       }, 'Parse::RecDescent::Production' ),
14554
                                                                bless( {
14555
                                                                         'number' => '1',
14556
                                                                         'strcount' => 2,
14557
                                                                         'dircount' => 0,
14558
                                                                         'uncommit' => undef,
14559
                                                                         'error' => undef,
14560
                                                                         'patcount' => 0,
14561
                                                                         'actcount' => 1,
14562
                                                                         'items' => [
14563
                                                                                      bless( {
14564
                                                                                               'pattern' => '(',
14565
                                                                                               'hashname' => '__STRING1__',
14566
                                                                                               'description' => '\'(\'',
14567
                                                                                               'lookahead' => 0,
14568
                                                                                               'line' => 149
14569
                                                                                             }, 'Parse::RecDescent::InterpLit' ),
14570
                                                                                      bless( {
14571
                                                                                               'subrule' => 'addressstruct',
14572
                                                                                               'expected' => undef,
14573
                                                                                               'min' => 1,
14574
                                                                                               'argcode' => undef,
14575
                                                                                               'max' => 100000000,
14576
                                                                                               'matchrule' => 0,
14577
                                                                                               'repspec' => 's',
14578
                                                                                               'lookahead' => 0,
14579
                                                                                               'line' => 149
14580
                                                                                             }, 'Parse::RecDescent::Repetition' ),
14581
                                                                                      bless( {
14582
                                                                                               'pattern' => ')',
14583
                                                                                               'hashname' => '__STRING2__',
14584
                                                                                               'description' => '\')\'',
14585
                                                                                               'lookahead' => 0,
14586
                                                                                               'line' => 149
14587
                                                                                             }, 'Parse::RecDescent::InterpLit' ),
14588
                                                                                      bless( {
14589
                                                                                               'hashname' => '__ACTION1__',
14590
                                                                                               'lookahead' => 0,
14591
                                                                                               'line' => 150,
14592
                                                                                               'code' => '{ $return = $item{NIL} || $item{\'addressstruct(s)\'} }'
14593
                                                                                             }, 'Parse::RecDescent::Action' )
14594
                                                                                    ],
14595
                                                                         'line' => 149
14596
                                                                       }, 'Parse::RecDescent::Production' )
14597
                                                              ],
14598
                                                   'name' => 'sender',
14599
                                                   'vars' => '',
14600
                                                   'line' => 149
14601
                                                 }, 'Parse::RecDescent::Rule' ),
14602
                              'QUOTED_STRING' => bless( {
14603
                                                          'impcount' => 0,
14604
                                                          'calls' => [
14605
                                                                       'DOUBLE_QUOTED_STRING',
14606
                                                                       'SINGLE_QUOTED_STRING'
14607
                                                                     ],
14608
                                                          'changed' => 0,
14609
                                                          'opcount' => 0,
14610
                                                          'prods' => [
14611
                                                                       bless( {
14612
                                                                                'number' => '0',
14613
                                                                                'strcount' => 0,
14614
                                                                                'dircount' => 0,
14615
                                                                                'uncommit' => undef,
14616
                                                                                'error' => undef,
14617
                                                                                'patcount' => 0,
14618
                                                                                'actcount' => 0,
14619
                                                                                'items' => [
14620
                                                                                             bless( {
14621
                                                                                                      'subrule' => 'DOUBLE_QUOTED_STRING',
14622
                                                                                                      'matchrule' => 0,
14623
                                                                                                      'implicit' => undef,
14624
                                                                                                      'argcode' => undef,
14625
                                                                                                      'lookahead' => 0,
14626
                                                                                                      'line' => 34
14627
                                                                                                    }, 'Parse::RecDescent::Subrule' )
14628
                                                                                           ],
14629
                                                                                'line' => undef
14630
                                                                              }, 'Parse::RecDescent::Production' ),
14631
                                                                       bless( {
14632
                                                                                'number' => '1',
14633
                                                                                'strcount' => 0,
14634
                                                                                'dircount' => 0,
14635
                                                                                'uncommit' => undef,
14636
                                                                                'error' => undef,
14637
                                                                                'patcount' => 0,
14638
                                                                                'actcount' => 1,
14639
                                                                                'items' => [
14640
                                                                                             bless( {
14641
                                                                                                      'subrule' => 'SINGLE_QUOTED_STRING',
14642
                                                                                                      'matchrule' => 0,
14643
                                                                                                      'implicit' => undef,
14644
                                                                                                      'argcode' => undef,
14645
                                                                                                      'lookahead' => 0,
14646
                                                                                                      'line' => 34
14647
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
14648
                                                                                             bless( {
14649
                                                                                                      'hashname' => '__ACTION1__',
14650
                                                                                                      'lookahead' => 0,
14651
                                                                                                      'line' => 34,
14652
                                                                                                      'code' => '{
14653
 
14654
	 $return = $item{DOUBLE_QUOTED_STRING}||$item{SINGLE_QUOTED_STRING} ;
14655
	 $return||defined($return);
14656
}'
14657
                                                                                                    }, 'Parse::RecDescent::Action' )
14658
                                                                                           ],
14659
                                                                                'line' => 34
14660
                                                                              }, 'Parse::RecDescent::Production' )
14661
                                                                     ],
14662
                                                          'name' => 'QUOTED_STRING',
14663
                                                          'vars' => '',
14664
                                                          'line' => 34
14665
                                                        }, 'Parse::RecDescent::Rule' ),
14666
                              'messagerfc822message' => bless( {
14667
                                                                 'impcount' => 0,
14668
                                                                 'calls' => [
14669
                                                                              'rfc822message',
14670
                                                                              'bodyparms',
14671
                                                                              'bodyid',
14672
                                                                              'bodydesc',
14673
                                                                              'bodyenc',
14674
                                                                              'bodysize',
14675
                                                                              'envelopestruct',
14676
                                                                              'bodystructure',
14677
                                                                              'textlines',
14678
                                                                              'bodyMD5',
14679
                                                                              'bodydisp',
14680
                                                                              'bodylang'
14681
                                                                            ],
14682
                                                                 'changed' => 0,
14683
                                                                 'opcount' => 0,
14684
                                                                 'prods' => [
14685
                                                                              bless( {
14686
                                                                                       'number' => '0',
14687
                                                                                       'strcount' => 0,
14688
                                                                                       'dircount' => 1,
14689
                                                                                       'uncommit' => undef,
14690
                                                                                       'error' => undef,
14691
                                                                                       'patcount' => 0,
14692
                                                                                       'actcount' => 1,
14693
                                                                                       'items' => [
14694
                                                                                                    bless( {
14695
                                                                                                             'subrule' => 'rfc822message',
14696
                                                                                                             'matchrule' => 0,
14697
                                                                                                             'implicit' => undef,
14698
                                                                                                             'argcode' => undef,
14699
                                                                                                             'lookahead' => 0,
14700
                                                                                                             'line' => 214
14701
                                                                                                           }, 'Parse::RecDescent::Subrule' ),
14702
                                                                                                    bless( {
14703
                                                                                                             'hashname' => '__DIRECTIVE1__',
14704
                                                                                                             'name' => '<commit>',
14705
                                                                                                             'lookahead' => 0,
14706
                                                                                                             'line' => 214,
14707
                                                                                                             'code' => '$commit = 1'
14708
                                                                                                           }, 'Parse::RecDescent::Directive' ),
14709
                                                                                                    bless( {
14710
                                                                                                             'subrule' => 'bodyparms',
14711
                                                                                                             'matchrule' => 0,
14712
                                                                                                             'implicit' => undef,
14713
                                                                                                             'argcode' => undef,
14714
                                                                                                             'lookahead' => 0,
14715
                                                                                                             'line' => 214
14716
                                                                                                           }, 'Parse::RecDescent::Subrule' ),
14717
                                                                                                    bless( {
14718
                                                                                                             'subrule' => 'bodyid',
14719
                                                                                                             'matchrule' => 0,
14720
                                                                                                             'implicit' => undef,
14721
                                                                                                             'argcode' => undef,
14722
                                                                                                             'lookahead' => 0,
14723
                                                                                                             'line' => 214
14724
                                                                                                           }, 'Parse::RecDescent::Subrule' ),
14725
                                                                                                    bless( {
14726
                                                                                                             'subrule' => 'bodydesc',
14727
                                                                                                             'matchrule' => 0,
14728
                                                                                                             'implicit' => undef,
14729
                                                                                                             'argcode' => undef,
14730
                                                                                                             'lookahead' => 0,
14731
                                                                                                             'line' => 214
14732
                                                                                                           }, 'Parse::RecDescent::Subrule' ),
14733
                                                                                                    bless( {
14734
                                                                                                             'subrule' => 'bodyenc',
14735
                                                                                                             'matchrule' => 0,
14736
                                                                                                             'implicit' => undef,
14737
                                                                                                             'argcode' => undef,
14738
                                                                                                             'lookahead' => 0,
14739
                                                                                                             'line' => 214
14740
                                                                                                           }, 'Parse::RecDescent::Subrule' ),
14741
                                                                                                    bless( {
14742
                                                                                                             'subrule' => 'bodysize',
14743
                                                                                                             'matchrule' => 0,
14744
                                                                                                             'implicit' => undef,
14745
                                                                                                             'argcode' => undef,
14746
                                                                                                             'lookahead' => 0,
14747
                                                                                                             'line' => 214
14748
                                                                                                           }, 'Parse::RecDescent::Subrule' ),
14749
                                                                                                    bless( {
14750
                                                                                                             'subrule' => 'envelopestruct',
14751
                                                                                                             'matchrule' => 0,
14752
                                                                                                             'implicit' => undef,
14753
                                                                                                             'argcode' => undef,
14754
                                                                                                             'lookahead' => 0,
14755
                                                                                                             'line' => 215
14756
                                                                                                           }, 'Parse::RecDescent::Subrule' ),
14757
                                                                                                    bless( {
14758
                                                                                                             'subrule' => 'bodystructure',
14759
                                                                                                             'matchrule' => 0,
14760
                                                                                                             'implicit' => undef,
14761
                                                                                                             'argcode' => undef,
14762
                                                                                                             'lookahead' => 0,
14763
                                                                                                             'line' => 215
14764
                                                                                                           }, 'Parse::RecDescent::Subrule' ),
14765
                                                                                                    bless( {
14766
                                                                                                             'subrule' => 'textlines',
14767
                                                                                                             'matchrule' => 0,
14768
                                                                                                             'implicit' => undef,
14769
                                                                                                             'argcode' => undef,
14770
                                                                                                             'lookahead' => 0,
14771
                                                                                                             'line' => 215
14772
                                                                                                           }, 'Parse::RecDescent::Subrule' ),
14773
                                                                                                    bless( {
14774
                                                                                                             'subrule' => 'bodyMD5',
14775
                                                                                                             'expected' => undef,
14776
                                                                                                             'min' => 0,
14777
                                                                                                             'argcode' => undef,
14778
                                                                                                             'max' => 1,
14779
                                                                                                             'matchrule' => 0,
14780
                                                                                                             'repspec' => '?',
14781
                                                                                                             'lookahead' => 0,
14782
                                                                                                             'line' => 216
14783
                                                                                                           }, 'Parse::RecDescent::Repetition' ),
14784
                                                                                                    bless( {
14785
                                                                                                             'subrule' => 'bodydisp',
14786
                                                                                                             'expected' => undef,
14787
                                                                                                             'min' => 0,
14788
                                                                                                             'argcode' => undef,
14789
                                                                                                             'max' => 1,
14790
                                                                                                             'matchrule' => 0,
14791
                                                                                                             'repspec' => '?',
14792
                                                                                                             'lookahead' => 0,
14793
                                                                                                             'line' => 216
14794
                                                                                                           }, 'Parse::RecDescent::Repetition' ),
14795
                                                                                                    bless( {
14796
                                                                                                             'subrule' => 'bodylang',
14797
                                                                                                             'expected' => undef,
14798
                                                                                                             'min' => 0,
14799
                                                                                                             'argcode' => undef,
14800
                                                                                                             'max' => 1,
14801
                                                                                                             'matchrule' => 0,
14802
                                                                                                             'repspec' => '?',
14803
                                                                                                             'lookahead' => 0,
14804
                                                                                                             'line' => 216
14805
                                                                                                           }, 'Parse::RecDescent::Repetition' ),
14806
                                                                                                    bless( {
14807
                                                                                                             'hashname' => '__ACTION1__',
14808
                                                                                                             'lookahead' => 0,
14809
                                                                                                             'line' => 217,
14810
                                                                                                             'code' => '{ 
14811
	  $return = {}; 
14812
	  foreach my $what (qw/	bodyparms bodyid bodydesc bodyenc bodysize 
14813
				envelopestruct bodystructure textlines
14814
				bodyMD5(?) bodydisp(?) bodylang(?)
14815
	  		     /
14816
	  ) {
14817
		my $k = $what; $k =~ s/\\(\\?\\)$//;
14818
                $return->{$k} = ref $item{$what} =~ \'ARRAY\'?
14819
                                        $item{$what}[0] : $item{$what};
14820
        }
14821
        while ( my($k,$v) = each %{$item{bodystructure}[0]} ) { $return->{$k} = $v }
14822
        while ( my($k,$v) = each %{$item{basicfields}}   ) { $return->{$k} = $v }
14823
	$return->{bodytype} 	= "MESSAGE" ; 
14824
	$return->{bodysubtype}= "RFC822" ;
14825
	$return||defined($return);
14826
	}'
14827
                                                                                                           }, 'Parse::RecDescent::Action' )
14828
                                                                                                  ],
14829
                                                                                       'line' => undef
14830
                                                                                     }, 'Parse::RecDescent::Production' )
14831
                                                                            ],
14832
                                                                 'name' => 'messagerfc822message',
14833
                                                                 'vars' => '',
14834
                                                                 'line' => 213
14835
                                                               }, 'Parse::RecDescent::Rule' ),
14836
                              'bodyenc' => bless( {
14837
                                                    'impcount' => 0,
14838
                                                    'calls' => [
14839
                                                                 'NIL',
14840
                                                                 'STRING',
14841
                                                                 'kvpair'
14842
                                                               ],
14843
                                                    'changed' => 0,
14844
                                                    'opcount' => 0,
14845
                                                    'prods' => [
14846
                                                                 bless( {
14847
                                                                          'number' => '0',
14848
                                                                          'strcount' => 0,
14849
                                                                          'dircount' => 0,
14850
                                                                          'uncommit' => undef,
14851
                                                                          'error' => undef,
14852
                                                                          'patcount' => 0,
14853
                                                                          'actcount' => 0,
14854
                                                                          'items' => [
14855
                                                                                       bless( {
14856
                                                                                                'subrule' => 'NIL',
14857
                                                                                                'matchrule' => 0,
14858
                                                                                                'implicit' => undef,
14859
                                                                                                'argcode' => undef,
14860
                                                                                                'lookahead' => 0,
14861
                                                                                                'line' => 92
14862
                                                                                              }, 'Parse::RecDescent::Subrule' )
14863
                                                                                     ],
14864
                                                                          'line' => undef
14865
                                                                        }, 'Parse::RecDescent::Production' ),
14866
                                                                 bless( {
14867
                                                                          'number' => '1',
14868
                                                                          'strcount' => 0,
14869
                                                                          'dircount' => 0,
14870
                                                                          'uncommit' => undef,
14871
                                                                          'error' => undef,
14872
                                                                          'patcount' => 0,
14873
                                                                          'actcount' => 0,
14874
                                                                          'items' => [
14875
                                                                                       bless( {
14876
                                                                                                'subrule' => 'STRING',
14877
                                                                                                'matchrule' => 0,
14878
                                                                                                'implicit' => undef,
14879
                                                                                                'argcode' => undef,
14880
                                                                                                'lookahead' => 0,
14881
                                                                                                'line' => 92
14882
                                                                                              }, 'Parse::RecDescent::Subrule' )
14883
                                                                                     ],
14884
                                                                          'line' => 92
14885
                                                                        }, 'Parse::RecDescent::Production' ),
14886
                                                                 bless( {
14887
                                                                          'number' => '2',
14888
                                                                          'strcount' => 2,
14889
                                                                          'dircount' => 0,
14890
                                                                          'uncommit' => undef,
14891
                                                                          'error' => undef,
14892
                                                                          'patcount' => 0,
14893
                                                                          'actcount' => 1,
14894
                                                                          'items' => [
14895
                                                                                       bless( {
14896
                                                                                                'pattern' => '(',
14897
                                                                                                'hashname' => '__STRING1__',
14898
                                                                                                'description' => '\'(\'',
14899
                                                                                                'lookahead' => 0,
14900
                                                                                                'line' => 92
14901
                                                                                              }, 'Parse::RecDescent::Literal' ),
14902
                                                                                       bless( {
14903
                                                                                                'subrule' => 'kvpair',
14904
                                                                                                'expected' => undef,
14905
                                                                                                'min' => 1,
14906
                                                                                                'argcode' => undef,
14907
                                                                                                'max' => 100000000,
14908
                                                                                                'matchrule' => 0,
14909
                                                                                                'repspec' => 's',
14910
                                                                                                'lookahead' => 0,
14911
                                                                                                'line' => 92
14912
                                                                                              }, 'Parse::RecDescent::Repetition' ),
14913
                                                                                       bless( {
14914
                                                                                                'pattern' => ')',
14915
                                                                                                'hashname' => '__STRING2__',
14916
                                                                                                'description' => '\')\'',
14917
                                                                                                'lookahead' => 0,
14918
                                                                                                'line' => 92
14919
                                                                                              }, 'Parse::RecDescent::Literal' ),
14920
                                                                                       bless( {
14921
                                                                                                'hashname' => '__ACTION1__',
14922
                                                                                                'lookahead' => 0,
14923
                                                                                                'line' => 93,
14924
                                                                                                'code' => '{
14925
		$return = $item{NIL} 		|| 
14926
			  $item{STRING} 	||
14927
			  { map { (%$_) } @{$item{\'kvpair(s)\'}} };
14928
		$return||defined($return);
14929
	}'
14930
                                                                                              }, 'Parse::RecDescent::Action' )
14931
                                                                                     ],
14932
                                                                          'line' => 92
14933
                                                                        }, 'Parse::RecDescent::Production' )
14934
                                                               ],
14935
                                                    'name' => 'bodyenc',
14936
                                                    'vars' => '',
14937
                                                    'line' => 92
14938
                                                  }, 'Parse::RecDescent::Rule' ),
14939
                              'bodydesc' => bless( {
14940
                                                     'impcount' => 0,
14941
                                                     'calls' => [
14942
                                                                  'NIL',
14943
                                                                  'STRING'
14944
                                                                ],
14945
                                                     'changed' => 0,
14946
                                                     'opcount' => 0,
14947
                                                     'prods' => [
14948
                                                                  bless( {
14949
                                                                           'number' => '0',
14950
                                                                           'strcount' => 0,
14951
                                                                           'dircount' => 0,
14952
                                                                           'uncommit' => undef,
14953
                                                                           'error' => undef,
14954
                                                                           'patcount' => 1,
14955
                                                                           'actcount' => 0,
14956
                                                                           'items' => [
14957
                                                                                        bless( {
14958
                                                                                                 'pattern' => '[()]',
14959
                                                                                                 'hashname' => '__PATTERN1__',
14960
                                                                                                 'description' => '/[()]/',
14961
                                                                                                 'lookahead' => -1,
14962
                                                                                                 'rdelim' => '/',
14963
                                                                                                 'line' => 90,
14964
                                                                                                 'mod' => '',
14965
                                                                                                 'ldelim' => '/'
14966
                                                                                               }, 'Parse::RecDescent::Token' ),
14967
                                                                                        bless( {
14968
                                                                                                 'subrule' => 'NIL',
14969
                                                                                                 'matchrule' => 0,
14970
                                                                                                 'implicit' => undef,
14971
                                                                                                 'argcode' => undef,
14972
                                                                                                 'lookahead' => 0,
14973
                                                                                                 'line' => 90
14974
                                                                                               }, 'Parse::RecDescent::Subrule' )
14975
                                                                                      ],
14976
                                                                           'line' => undef
14977
                                                                         }, 'Parse::RecDescent::Production' ),
14978
                                                                  bless( {
14979
                                                                           'number' => '1',
14980
                                                                           'strcount' => 0,
14981
                                                                           'dircount' => 0,
14982
                                                                           'uncommit' => undef,
14983
                                                                           'error' => undef,
14984
                                                                           'patcount' => 0,
14985
                                                                           'actcount' => 1,
14986
                                                                           'items' => [
14987
                                                                                        bless( {
14988
                                                                                                 'subrule' => 'STRING',
14989
                                                                                                 'matchrule' => 0,
14990
                                                                                                 'implicit' => undef,
14991
                                                                                                 'argcode' => undef,
14992
                                                                                                 'lookahead' => 0,
14993
                                                                                                 'line' => 90
14994
                                                                                               }, 'Parse::RecDescent::Subrule' ),
14995
                                                                                        bless( {
14996
                                                                                                 'hashname' => '__ACTION1__',
14997
                                                                                                 'lookahead' => 0,
14998
                                                                                                 'line' => 91,
14999
                                                                                                 'code' => '{ $return = $item{NIL} || $item{STRING} ; $return||defined($return);}'
15000
                                                                                               }, 'Parse::RecDescent::Action' )
15001
                                                                                      ],
15002
                                                                           'line' => 90
15003
                                                                         }, 'Parse::RecDescent::Production' )
15004
                                                                ],
15005
                                                     'name' => 'bodydesc',
15006
                                                     'vars' => '',
15007
                                                     'line' => 90
15008
                                                   }, 'Parse::RecDescent::Rule' ),
15009
                              'start' => bless( {
15010
                                                  'impcount' => 0,
15011
                                                  'calls' => [
15012
                                                               'part'
15013
                                                             ],
15014
                                                  'changed' => 0,
15015
                                                  'opcount' => 0,
15016
                                                  'prods' => [
15017
                                                               bless( {
15018
                                                                        'number' => '0',
15019
                                                                        'strcount' => 0,
15020
                                                                        'dircount' => 0,
15021
                                                                        'uncommit' => undef,
15022
                                                                        'error' => undef,
15023
                                                                        'patcount' => 2,
15024
                                                                        'actcount' => 1,
15025
                                                                        'items' => [
15026
                                                                                     bless( {
15027
                                                                                              'pattern' => '.*\\(.*BODYSTRUCTURE \\(',
15028
                                                                                              'hashname' => '__PATTERN1__',
15029
                                                                                              'description' => '/.*\\\\(.*BODYSTRUCTURE \\\\(/i',
15030
                                                                                              'lookahead' => 0,
15031
                                                                                              'rdelim' => '/',
15032
                                                                                              'line' => 278,
15033
                                                                                              'mod' => 'i',
15034
                                                                                              'ldelim' => '/'
15035
                                                                                            }, 'Parse::RecDescent::Token' ),
15036
                                                                                     bless( {
15037
                                                                                              'subrule' => 'part',
15038
                                                                                              'expected' => undef,
15039
                                                                                              'min' => 1,
15040
                                                                                              'argcode' => undef,
15041
                                                                                              'max' => 1,
15042
                                                                                              'matchrule' => 0,
15043
                                                                                              'repspec' => '1',
15044
                                                                                              'lookahead' => 0,
15045
                                                                                              'line' => 278
15046
                                                                                            }, 'Parse::RecDescent::Repetition' ),
15047
                                                                                     bless( {
15048
                                                                                              'pattern' => '\\).*\\)\\r?\\n?',
15049
                                                                                              'hashname' => '__PATTERN2__',
15050
                                                                                              'description' => '/\\\\).*\\\\)\\\\r?\\\\n?/',
15051
                                                                                              'lookahead' => 0,
15052
                                                                                              'rdelim' => '/',
15053
                                                                                              'line' => 278,
15054
                                                                                              'mod' => '',
15055
                                                                                              'ldelim' => '/'
15056
                                                                                            }, 'Parse::RecDescent::Token' ),
15057
                                                                                     bless( {
15058
                                                                                              'hashname' => '__ACTION1__',
15059
                                                                                              'lookahead' => 0,
15060
                                                                                              'line' => 279,
15061
                                                                                              'code' => '{
15062
			#print STDERR "item = ",Data::Dumper->Dump([\\%item],[\'$item\']);
15063
			$return = $item{\'part(1)\'}[0];
15064
			$return||defined($return);
15065
		}'
15066
                                                                                            }, 'Parse::RecDescent::Action' )
15067
                                                                                   ],
15068
                                                                        'line' => undef
15069
                                                                      }, 'Parse::RecDescent::Production' )
15070
                                                             ],
15071
                                                  'name' => 'start',
15072
                                                  'vars' => '',
15073
                                                  'line' => 278
15074
                                                }, 'Parse::RecDescent::Rule' ),
15075
                              'RFC822' => bless( {
15076
                                                   'impcount' => 0,
15077
                                                   'calls' => [],
15078
                                                   'changed' => 0,
15079
                                                   'opcount' => 0,
15080
                                                   'prods' => [
15081
                                                                bless( {
15082
                                                                         'number' => '0',
15083
                                                                         'strcount' => 0,
15084
                                                                         'dircount' => 0,
15085
                                                                         'uncommit' => undef,
15086
                                                                         'error' => undef,
15087
                                                                         'patcount' => 1,
15088
                                                                         'actcount' => 1,
15089
                                                                         'items' => [
15090
                                                                                      bless( {
15091
                                                                                               'pattern' => '^"RFC822"|^RFC822',
15092
                                                                                               'hashname' => '__PATTERN1__',
15093
                                                                                               'description' => '/^"RFC822"|^RFC822/i',
15094
                                                                                               'lookahead' => 0,
15095
                                                                                               'rdelim' => '/',
15096
                                                                                               'line' => 16,
15097
                                                                                               'mod' => 'i',
15098
                                                                                               'ldelim' => '/'
15099
                                                                                             }, 'Parse::RecDescent::Token' ),
15100
                                                                                      bless( {
15101
                                                                                               'hashname' => '__ACTION1__',
15102
                                                                                               'lookahead' => 0,
15103
                                                                                               'line' => 16,
15104
                                                                                               'code' => '{ $return = "RFC822" 	}'
15105
                                                                                             }, 'Parse::RecDescent::Action' )
15106
                                                                                    ],
15107
                                                                         'line' => undef
15108
                                                                       }, 'Parse::RecDescent::Production' )
15109
                                                              ],
15110
                                                   'name' => 'RFC822',
15111
                                                   'vars' => '',
15112
                                                   'line' => 16
15113
                                                 }, 'Parse::RecDescent::Rule' ),
15114
                              'textmessage' => bless( {
15115
                                                        'impcount' => 0,
15116
                                                        'calls' => [
15117
                                                                     'TEXT',
15118
                                                                     'basicfields',
15119
                                                                     'textlines',
15120
                                                                     'bodyMD5',
15121
                                                                     'bodydisp',
15122
                                                                     'bodylang'
15123
                                                                   ],
15124
                                                        'changed' => 0,
15125
                                                        'opcount' => 0,
15126
                                                        'prods' => [
15127
                                                                     bless( {
15128
                                                                              'number' => '0',
15129
                                                                              'strcount' => 0,
15130
                                                                              'dircount' => 1,
15131
                                                                              'uncommit' => undef,
15132
                                                                              'error' => undef,
15133
                                                                              'patcount' => 0,
15134
                                                                              'actcount' => 1,
15135
                                                                              'items' => [
15136
                                                                                           bless( {
15137
                                                                                                    'subrule' => 'TEXT',
15138
                                                                                                    'matchrule' => 0,
15139
                                                                                                    'implicit' => undef,
15140
                                                                                                    'argcode' => undef,
15141
                                                                                                    'lookahead' => 0,
15142
                                                                                                    'line' => 192
15143
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
15144
                                                                                           bless( {
15145
                                                                                                    'hashname' => '__DIRECTIVE1__',
15146
                                                                                                    'name' => '<commit>',
15147
                                                                                                    'lookahead' => 0,
15148
                                                                                                    'line' => 192,
15149
                                                                                                    'code' => '$commit = 1'
15150
                                                                                                  }, 'Parse::RecDescent::Directive' ),
15151
                                                                                           bless( {
15152
                                                                                                    'subrule' => 'basicfields',
15153
                                                                                                    'matchrule' => 0,
15154
                                                                                                    'implicit' => undef,
15155
                                                                                                    'argcode' => undef,
15156
                                                                                                    'lookahead' => 0,
15157
                                                                                                    'line' => 192
15158
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
15159
                                                                                           bless( {
15160
                                                                                                    'subrule' => 'textlines',
15161
                                                                                                    'expected' => undef,
15162
                                                                                                    'min' => 0,
15163
                                                                                                    'argcode' => undef,
15164
                                                                                                    'max' => 1,
15165
                                                                                                    'matchrule' => 0,
15166
                                                                                                    'repspec' => '?',
15167
                                                                                                    'lookahead' => 0,
15168
                                                                                                    'line' => 192
15169
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
15170
                                                                                           bless( {
15171
                                                                                                    'subrule' => 'bodyMD5',
15172
                                                                                                    'expected' => undef,
15173
                                                                                                    'min' => 0,
15174
                                                                                                    'argcode' => undef,
15175
                                                                                                    'max' => 1,
15176
                                                                                                    'matchrule' => 0,
15177
                                                                                                    'repspec' => '?',
15178
                                                                                                    'lookahead' => 0,
15179
                                                                                                    'line' => 192
15180
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
15181
                                                                                           bless( {
15182
                                                                                                    'subrule' => 'bodydisp',
15183
                                                                                                    'expected' => undef,
15184
                                                                                                    'min' => 0,
15185
                                                                                                    'argcode' => undef,
15186
                                                                                                    'max' => 1,
15187
                                                                                                    'matchrule' => 0,
15188
                                                                                                    'repspec' => '?',
15189
                                                                                                    'lookahead' => 0,
15190
                                                                                                    'line' => 192
15191
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
15192
                                                                                           bless( {
15193
                                                                                                    'subrule' => 'bodylang',
15194
                                                                                                    'expected' => undef,
15195
                                                                                                    'min' => 0,
15196
                                                                                                    'argcode' => undef,
15197
                                                                                                    'max' => 1,
15198
                                                                                                    'matchrule' => 0,
15199
                                                                                                    'repspec' => '?',
15200
                                                                                                    'lookahead' => 0,
15201
                                                                                                    'line' => 192
15202
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
15203
                                                                                           bless( {
15204
                                                                                                    'hashname' => '__ACTION1__',
15205
                                                                                                    'lookahead' => 0,
15206
                                                                                                    'line' => 193,
15207
                                                                                                    'code' => '{ 
15208
	  $return = $item{basicfields}||{};
15209
	  $return->{bodytype} = \'TEXT\';
15210
	  foreach my $what (qw/textlines(?) bodyMD5(?) bodydisp(?) bodylang(?)/) {
15211
		my $k = $what; $k =~ s/\\(\\?\\)$//;
15212
		ref($item{$what}) and $return->{$k} = $item{$what}[0];
15213
	  }
15214
	  $return||defined($return);
15215
        }'
15216
                                                                                                  }, 'Parse::RecDescent::Action' )
15217
                                                                                         ],
15218
                                                                              'line' => undef
15219
                                                                            }, 'Parse::RecDescent::Production' )
15220
                                                                   ],
15221
                                                        'name' => 'textmessage',
15222
                                                        'vars' => '',
15223
                                                        'line' => 192
15224
                                                      }, 'Parse::RecDescent::Rule' ),
15225
                              'bodyid' => bless( {
15226
                                                   'impcount' => 0,
15227
                                                   'calls' => [
15228
                                                                'NIL',
15229
                                                                'STRING'
15230
                                                              ],
15231
                                                   'changed' => 0,
15232
                                                   'opcount' => 0,
15233
                                                   'prods' => [
15234
                                                                bless( {
15235
                                                                         'number' => '0',
15236
                                                                         'strcount' => 0,
15237
                                                                         'dircount' => 0,
15238
                                                                         'uncommit' => undef,
15239
                                                                         'error' => undef,
15240
                                                                         'patcount' => 1,
15241
                                                                         'actcount' => 0,
15242
                                                                         'items' => [
15243
                                                                                      bless( {
15244
                                                                                               'pattern' => '[()]',
15245
                                                                                               'hashname' => '__PATTERN1__',
15246
                                                                                               'description' => '/[()]/',
15247
                                                                                               'lookahead' => -1,
15248
                                                                                               'rdelim' => '/',
15249
                                                                                               'line' => 88,
15250
                                                                                               'mod' => '',
15251
                                                                                               'ldelim' => '/'
15252
                                                                                             }, 'Parse::RecDescent::Token' ),
15253
                                                                                      bless( {
15254
                                                                                               'subrule' => 'NIL',
15255
                                                                                               'matchrule' => 0,
15256
                                                                                               'implicit' => undef,
15257
                                                                                               'argcode' => undef,
15258
                                                                                               'lookahead' => 0,
15259
                                                                                               'line' => 88
15260
                                                                                             }, 'Parse::RecDescent::Subrule' )
15261
                                                                                    ],
15262
                                                                         'line' => undef
15263
                                                                       }, 'Parse::RecDescent::Production' ),
15264
                                                                bless( {
15265
                                                                         'number' => '1',
15266
                                                                         'strcount' => 0,
15267
                                                                         'dircount' => 0,
15268
                                                                         'uncommit' => undef,
15269
                                                                         'error' => undef,
15270
                                                                         'patcount' => 0,
15271
                                                                         'actcount' => 1,
15272
                                                                         'items' => [
15273
                                                                                      bless( {
15274
                                                                                               'subrule' => 'STRING',
15275
                                                                                               'matchrule' => 0,
15276
                                                                                               'implicit' => undef,
15277
                                                                                               'argcode' => undef,
15278
                                                                                               'lookahead' => 0,
15279
                                                                                               'line' => 88
15280
                                                                                             }, 'Parse::RecDescent::Subrule' ),
15281
                                                                                      bless( {
15282
                                                                                               'hashname' => '__ACTION1__',
15283
                                                                                               'lookahead' => 0,
15284
                                                                                               'line' => 89,
15285
                                                                                               'code' => '{ $return = $item{NIL} || $item{STRING} ; $return||defined($return);}'
15286
                                                                                             }, 'Parse::RecDescent::Action' )
15287
                                                                                    ],
15288
                                                                         'line' => 88
15289
                                                                       }, 'Parse::RecDescent::Production' )
15290
                                                              ],
15291
                                                   'name' => 'bodyid',
15292
                                                   'vars' => '',
15293
                                                   'line' => 88
15294
                                                 }, 'Parse::RecDescent::Rule' ),
15295
                              'othertypemessage' => bless( {
15296
                                                             'impcount' => 0,
15297
                                                             'calls' => [
15298
                                                                          'bodytype',
15299
                                                                          'basicfields',
15300
                                                                          'bodyparms',
15301
                                                                          'bodydisp',
15302
                                                                          'bodylang'
15303
                                                                        ],
15304
                                                             'changed' => 0,
15305
                                                             'opcount' => 0,
15306
                                                             'prods' => [
15307
                                                                          bless( {
15308
                                                                                   'number' => '0',
15309
                                                                                   'strcount' => 0,
15310
                                                                                   'dircount' => 0,
15311
                                                                                   'uncommit' => undef,
15312
                                                                                   'error' => undef,
15313
                                                                                   'patcount' => 0,
15314
                                                                                   'actcount' => 1,
15315
                                                                                   'items' => [
15316
                                                                                                bless( {
15317
                                                                                                         'subrule' => 'bodytype',
15318
                                                                                                         'matchrule' => 0,
15319
                                                                                                         'implicit' => undef,
15320
                                                                                                         'argcode' => undef,
15321
                                                                                                         'lookahead' => 0,
15322
                                                                                                         'line' => 203
15323
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
15324
                                                                                                bless( {
15325
                                                                                                         'subrule' => 'basicfields',
15326
                                                                                                         'matchrule' => 0,
15327
                                                                                                         'implicit' => undef,
15328
                                                                                                         'argcode' => undef,
15329
                                                                                                         'lookahead' => 0,
15330
                                                                                                         'line' => 203
15331
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
15332
                                                                                                bless( {
15333
                                                                                                         'subrule' => 'bodyparms',
15334
                                                                                                         'expected' => undef,
15335
                                                                                                         'min' => 0,
15336
                                                                                                         'argcode' => undef,
15337
                                                                                                         'max' => 1,
15338
                                                                                                         'matchrule' => 0,
15339
                                                                                                         'repspec' => '?',
15340
                                                                                                         'lookahead' => 0,
15341
                                                                                                         'line' => 203
15342
                                                                                                       }, 'Parse::RecDescent::Repetition' ),
15343
                                                                                                bless( {
15344
                                                                                                         'subrule' => 'bodydisp',
15345
                                                                                                         'expected' => undef,
15346
                                                                                                         'min' => 0,
15347
                                                                                                         'argcode' => undef,
15348
                                                                                                         'max' => 1,
15349
                                                                                                         'matchrule' => 0,
15350
                                                                                                         'repspec' => '?',
15351
                                                                                                         'lookahead' => 0,
15352
                                                                                                         'line' => 203
15353
                                                                                                       }, 'Parse::RecDescent::Repetition' ),
15354
                                                                                                bless( {
15355
                                                                                                         'subrule' => 'bodylang',
15356
                                                                                                         'expected' => undef,
15357
                                                                                                         'min' => 0,
15358
                                                                                                         'argcode' => undef,
15359
                                                                                                         'max' => 1,
15360
                                                                                                         'matchrule' => 0,
15361
                                                                                                         'repspec' => '?',
15362
                                                                                                         'lookahead' => 0,
15363
                                                                                                         'line' => 203
15364
                                                                                                       }, 'Parse::RecDescent::Repetition' ),
15365
                                                                                                bless( {
15366
                                                                                                         'hashname' => '__ACTION1__',
15367
                                                                                                         'lookahead' => 0,
15368
                                                                                                         'line' => 204,
15369
                                                                                                         'code' => '{ $return = {}; 
15370
	  foreach my $what (qw/bodytype bodyparms(?) bodydisp(?) bodylang(?)/) {
15371
		my $k = $what; $k =~ s/\\(\\?\\)$//;
15372
		$return->{$k} = ref($item{$what})? $item{$what}[0] : $item{$what} ;
15373
	  }
15374
	  while ( my($k,$v) = each %{$item{basicfields}} ) { $return->{$k} = $v }
15375
	  $return||defined($return);
15376
	}'
15377
                                                                                                       }, 'Parse::RecDescent::Action' )
15378
                                                                                              ],
15379
                                                                                   'line' => undef
15380
                                                                                 }, 'Parse::RecDescent::Production' )
15381
                                                                        ],
15382
                                                             'name' => 'othertypemessage',
15383
                                                             'vars' => '',
15384
                                                             'line' => 203
15385
                                                           }, 'Parse::RecDescent::Rule' ),
15386
                              'kvpair' => bless( {
15387
                                                   'impcount' => 0,
15388
                                                   'calls' => [
15389
                                                                'key',
15390
                                                                'value'
15391
                                                              ],
15392
                                                   'changed' => 0,
15393
                                                   'opcount' => 0,
15394
                                                   'prods' => [
15395
                                                                bless( {
15396
                                                                         'number' => '0',
15397
                                                                         'strcount' => 1,
15398
                                                                         'dircount' => 0,
15399
                                                                         'uncommit' => undef,
15400
                                                                         'error' => undef,
15401
                                                                         'patcount' => 0,
15402
                                                                         'actcount' => 1,
15403
                                                                         'items' => [
15404
                                                                                      bless( {
15405
                                                                                               'pattern' => ')',
15406
                                                                                               'hashname' => '__STRING1__',
15407
                                                                                               'description' => '\')\'',
15408
                                                                                               'lookahead' => -1,
15409
                                                                                               'line' => 68
15410
                                                                                             }, 'Parse::RecDescent::InterpLit' ),
15411
                                                                                      bless( {
15412
                                                                                               'subrule' => 'key',
15413
                                                                                               'matchrule' => 0,
15414
                                                                                               'implicit' => undef,
15415
                                                                                               'argcode' => undef,
15416
                                                                                               'lookahead' => 0,
15417
                                                                                               'line' => 68
15418
                                                                                             }, 'Parse::RecDescent::Subrule' ),
15419
                                                                                      bless( {
15420
                                                                                               'subrule' => 'value',
15421
                                                                                               'matchrule' => 0,
15422
                                                                                               'implicit' => undef,
15423
                                                                                               'argcode' => undef,
15424
                                                                                               'lookahead' => 0,
15425
                                                                                               'line' => 68
15426
                                                                                             }, 'Parse::RecDescent::Subrule' ),
15427
                                                                                      bless( {
15428
                                                                                               'hashname' => '__ACTION1__',
15429
                                                                                               'lookahead' => 0,
15430
                                                                                               'line' => 69,
15431
                                                                                               'code' => '{ $return = { $item{key} => $item{value} }; $return||defined($return);}'
15432
                                                                                             }, 'Parse::RecDescent::Action' )
15433
                                                                                    ],
15434
                                                                         'line' => undef
15435
                                                                       }, 'Parse::RecDescent::Production' )
15436
                                                              ],
15437
                                                   'name' => 'kvpair',
15438
                                                   'vars' => '',
15439
                                                   'line' => 68
15440
                                                 }, 'Parse::RecDescent::Rule' ),
15441
                              'bodysize' => bless( {
15442
                                                     'impcount' => 0,
15443
                                                     'calls' => [
15444
                                                                  'NIL',
15445
                                                                  'NUMBER'
15446
                                                                ],
15447
                                                     'changed' => 0,
15448
                                                     'opcount' => 0,
15449
                                                     'prods' => [
15450
                                                                  bless( {
15451
                                                                           'number' => '0',
15452
                                                                           'strcount' => 0,
15453
                                                                           'dircount' => 0,
15454
                                                                           'uncommit' => undef,
15455
                                                                           'error' => undef,
15456
                                                                           'patcount' => 1,
15457
                                                                           'actcount' => 0,
15458
                                                                           'items' => [
15459
                                                                                        bless( {
15460
                                                                                                 'pattern' => '[()]',
15461
                                                                                                 'hashname' => '__PATTERN1__',
15462
                                                                                                 'description' => '/[()]/',
15463
                                                                                                 'lookahead' => -1,
15464
                                                                                                 'rdelim' => '/',
15465
                                                                                                 'line' => 99,
15466
                                                                                                 'mod' => '',
15467
                                                                                                 'ldelim' => '/'
15468
                                                                                               }, 'Parse::RecDescent::Token' ),
15469
                                                                                        bless( {
15470
                                                                                                 'subrule' => 'NIL',
15471
                                                                                                 'matchrule' => 0,
15472
                                                                                                 'implicit' => undef,
15473
                                                                                                 'argcode' => undef,
15474
                                                                                                 'lookahead' => 0,
15475
                                                                                                 'line' => 99
15476
                                                                                               }, 'Parse::RecDescent::Subrule' )
15477
                                                                                      ],
15478
                                                                           'line' => undef
15479
                                                                         }, 'Parse::RecDescent::Production' ),
15480
                                                                  bless( {
15481
                                                                           'number' => '1',
15482
                                                                           'strcount' => 0,
15483
                                                                           'dircount' => 0,
15484
                                                                           'uncommit' => undef,
15485
                                                                           'error' => undef,
15486
                                                                           'patcount' => 0,
15487
                                                                           'actcount' => 1,
15488
                                                                           'items' => [
15489
                                                                                        bless( {
15490
                                                                                                 'subrule' => 'NUMBER',
15491
                                                                                                 'matchrule' => 0,
15492
                                                                                                 'implicit' => undef,
15493
                                                                                                 'argcode' => undef,
15494
                                                                                                 'lookahead' => 0,
15495
                                                                                                 'line' => 99
15496
                                                                                               }, 'Parse::RecDescent::Subrule' ),
15497
                                                                                        bless( {
15498
                                                                                                 'hashname' => '__ACTION1__',
15499
                                                                                                 'lookahead' => 0,
15500
                                                                                                 'line' => 100,
15501
                                                                                                 'code' => '{ $return = $item{NIL} || $item{NUMBER} ;$return||defined($return);}'
15502
                                                                                               }, 'Parse::RecDescent::Action' )
15503
                                                                                      ],
15504
                                                                           'line' => 99
15505
                                                                         }, 'Parse::RecDescent::Production' )
15506
                                                                ],
15507
                                                     'name' => 'bodysize',
15508
                                                     'vars' => '',
15509
                                                     'line' => 99
15510
                                                   }, 'Parse::RecDescent::Rule' ),
15511
                              'STRING' => bless( {
15512
                                                   'impcount' => 0,
15513
                                                   'calls' => [
15514
                                                                'QUOTED_STRING',
15515
                                                                'BARESTRING'
15516
                                                              ],
15517
                                                   'changed' => 0,
15518
                                                   'opcount' => 0,
15519
                                                   'prods' => [
15520
                                                                bless( {
15521
                                                                         'number' => '0',
15522
                                                                         'strcount' => 0,
15523
                                                                         'dircount' => 0,
15524
                                                                         'uncommit' => undef,
15525
                                                                         'error' => undef,
15526
                                                                         'patcount' => 0,
15527
                                                                         'actcount' => 0,
15528
                                                                         'items' => [
15529
                                                                                      bless( {
15530
                                                                                               'subrule' => 'QUOTED_STRING',
15531
                                                                                               'matchrule' => 0,
15532
                                                                                               'implicit' => undef,
15533
                                                                                               'argcode' => undef,
15534
                                                                                               'lookahead' => 0,
15535
                                                                                               'line' => 44
15536
                                                                                             }, 'Parse::RecDescent::Subrule' )
15537
                                                                                    ],
15538
                                                                         'line' => undef
15539
                                                                       }, 'Parse::RecDescent::Production' ),
15540
                                                                bless( {
15541
                                                                         'number' => '1',
15542
                                                                         'strcount' => 0,
15543
                                                                         'dircount' => 0,
15544
                                                                         'uncommit' => undef,
15545
                                                                         'error' => undef,
15546
                                                                         'patcount' => 0,
15547
                                                                         'actcount' => 1,
15548
                                                                         'items' => [
15549
                                                                                      bless( {
15550
                                                                                               'subrule' => 'BARESTRING',
15551
                                                                                               'matchrule' => 0,
15552
                                                                                               'implicit' => undef,
15553
                                                                                               'argcode' => undef,
15554
                                                                                               'lookahead' => 0,
15555
                                                                                               'line' => 44
15556
                                                                                             }, 'Parse::RecDescent::Subrule' ),
15557
                                                                                      bless( {
15558
                                                                                               'hashname' => '__ACTION1__',
15559
                                                                                               'lookahead' => 0,
15560
                                                                                               'line' => 44,
15561
                                                                                               'code' => '{
15562
	 $return = $item{QUOTED_STRING}||$item{BARESTRING} ;
15563
	 $return||defined($return);
15564
}'
15565
                                                                                             }, 'Parse::RecDescent::Action' )
15566
                                                                                    ],
15567
                                                                         'line' => 44
15568
                                                                       }, 'Parse::RecDescent::Production' )
15569
                                                              ],
15570
                                                   'name' => 'STRING',
15571
                                                   'vars' => '',
15572
                                                   'line' => 44
15573
                                                 }, 'Parse::RecDescent::Rule' ),
15574
                              'bodytype' => bless( {
15575
                                                     'impcount' => 0,
15576
                                                     'calls' => [
15577
                                                                  'STRING'
15578
                                                                ],
15579
                                                     'changed' => 0,
15580
                                                     'opcount' => 0,
15581
                                                     'prods' => [
15582
                                                                  bless( {
15583
                                                                           'number' => '0',
15584
                                                                           'strcount' => 0,
15585
                                                                           'dircount' => 0,
15586
                                                                           'uncommit' => undef,
15587
                                                                           'error' => undef,
15588
                                                                           'patcount' => 0,
15589
                                                                           'actcount' => 1,
15590
                                                                           'items' => [
15591
                                                                                        bless( {
15592
                                                                                                 'subrule' => 'STRING',
15593
                                                                                                 'matchrule' => 0,
15594
                                                                                                 'implicit' => undef,
15595
                                                                                                 'argcode' => undef,
15596
                                                                                                 'lookahead' => 0,
15597
                                                                                                 'line' => 70
15598
                                                                                               }, 'Parse::RecDescent::Subrule' ),
15599
                                                                                        bless( {
15600
                                                                                                 'hashname' => '__ACTION1__',
15601
                                                                                                 'lookahead' => 0,
15602
                                                                                                 'line' => 71,
15603
                                                                                                 'code' => '{ $return = $item{STRING} ; $return||defined($return);}'
15604
                                                                                               }, 'Parse::RecDescent::Action' )
15605
                                                                                      ],
15606
                                                                           'line' => undef
15607
                                                                         }, 'Parse::RecDescent::Production' )
15608
                                                                ],
15609
                                                     'name' => 'bodytype',
15610
                                                     'vars' => '',
15611
                                                     'line' => 70
15612
                                                   }, 'Parse::RecDescent::Rule' ),
15613
                              'TEXT' => bless( {
15614
                                                 'impcount' => 0,
15615
                                                 'calls' => [],
15616
                                                 'changed' => 0,
15617
                                                 'opcount' => 0,
15618
                                                 'prods' => [
15619
                                                              bless( {
15620
                                                                       'number' => '0',
15621
                                                                       'strcount' => 0,
15622
                                                                       'dircount' => 0,
15623
                                                                       'uncommit' => undef,
15624
                                                                       'error' => undef,
15625
                                                                       'patcount' => 1,
15626
                                                                       'actcount' => 1,
15627
                                                                       'items' => [
15628
                                                                                    bless( {
15629
                                                                                             'pattern' => '^"TEXT"|^TEXT',
15630
                                                                                             'hashname' => '__PATTERN1__',
15631
                                                                                             'description' => '/^"TEXT"|^TEXT/i',
15632
                                                                                             'lookahead' => 0,
15633
                                                                                             'rdelim' => '/',
15634
                                                                                             'line' => 12,
15635
                                                                                             'mod' => 'i',
15636
                                                                                             'ldelim' => '/'
15637
                                                                                           }, 'Parse::RecDescent::Token' ),
15638
                                                                                    bless( {
15639
                                                                                             'hashname' => '__ACTION1__',
15640
                                                                                             'lookahead' => 0,
15641
                                                                                             'line' => 12,
15642
                                                                                             'code' => '{ $return = "TEXT" }'
15643
                                                                                           }, 'Parse::RecDescent::Action' )
15644
                                                                                  ],
15645
                                                                       'line' => undef
15646
                                                                     }, 'Parse::RecDescent::Production' )
15647
                                                            ],
15648
                                                 'name' => 'TEXT',
15649
                                                 'vars' => '',
15650
                                                 'line' => 11
15651
                                               }, 'Parse::RecDescent::Rule' ),
15652
                              'to' => bless( {
15653
                                               'impcount' => 0,
15654
                                               'calls' => [
15655
                                                            'NIL',
15656
                                                            'addressstruct'
15657
                                                          ],
15658
                                               'changed' => 0,
15659
                                               'opcount' => 0,
15660
                                               'prods' => [
15661
                                                            bless( {
15662
                                                                     'number' => '0',
15663
                                                                     'strcount' => 0,
15664
                                                                     'dircount' => 0,
15665
                                                                     'uncommit' => undef,
15666
                                                                     'error' => undef,
15667
                                                                     'patcount' => 0,
15668
                                                                     'actcount' => 0,
15669
                                                                     'items' => [
15670
                                                                                  bless( {
15671
                                                                                           'subrule' => 'NIL',
15672
                                                                                           'matchrule' => 0,
15673
                                                                                           'implicit' => undef,
15674
                                                                                           'argcode' => undef,
15675
                                                                                           'lookahead' => 0,
15676
                                                                                           'line' => 152
15677
                                                                                         }, 'Parse::RecDescent::Subrule' )
15678
                                                                                ],
15679
                                                                     'line' => undef
15680
                                                                   }, 'Parse::RecDescent::Production' ),
15681
                                                            bless( {
15682
                                                                     'number' => '1',
15683
                                                                     'strcount' => 2,
15684
                                                                     'dircount' => 0,
15685
                                                                     'uncommit' => undef,
15686
                                                                     'error' => undef,
15687
                                                                     'patcount' => 0,
15688
                                                                     'actcount' => 1,
15689
                                                                     'items' => [
15690
                                                                                  bless( {
15691
                                                                                           'pattern' => '(',
15692
                                                                                           'hashname' => '__STRING1__',
15693
                                                                                           'description' => '\'(\'',
15694
                                                                                           'lookahead' => 0,
15695
                                                                                           'line' => 152
15696
                                                                                         }, 'Parse::RecDescent::InterpLit' ),
15697
                                                                                  bless( {
15698
                                                                                           'subrule' => 'addressstruct',
15699
                                                                                           'expected' => undef,
15700
                                                                                           'min' => 1,
15701
                                                                                           'argcode' => undef,
15702
                                                                                           'max' => 100000000,
15703
                                                                                           'matchrule' => 0,
15704
                                                                                           'repspec' => 's',
15705
                                                                                           'lookahead' => 0,
15706
                                                                                           'line' => 152
15707
                                                                                         }, 'Parse::RecDescent::Repetition' ),
15708
                                                                                  bless( {
15709
                                                                                           'pattern' => ')',
15710
                                                                                           'hashname' => '__STRING2__',
15711
                                                                                           'description' => '\')\'',
15712
                                                                                           'lookahead' => 0,
15713
                                                                                           'line' => 152
15714
                                                                                         }, 'Parse::RecDescent::InterpLit' ),
15715
                                                                                  bless( {
15716
                                                                                           'hashname' => '__ACTION1__',
15717
                                                                                           'lookahead' => 0,
15718
                                                                                           'line' => 153,
15719
                                                                                           'code' => '{ $return = $item{NIL} || $item{\'addressstruct(s)\'} }'
15720
                                                                                         }, 'Parse::RecDescent::Action' )
15721
                                                                                ],
15722
                                                                     'line' => 152
15723
                                                                   }, 'Parse::RecDescent::Production' )
15724
                                                          ],
15725
                                               'name' => 'to',
15726
                                               'vars' => '',
15727
                                               'line' => 152
15728
                                             }, 'Parse::RecDescent::Rule' ),
15729
                              'NIL' => bless( {
15730
                                                'impcount' => 0,
15731
                                                'calls' => [],
15732
                                                'changed' => 0,
15733
                                                'opcount' => 0,
15734
                                                'prods' => [
15735
                                                             bless( {
15736
                                                                      'number' => '0',
15737
                                                                      'strcount' => 0,
15738
                                                                      'dircount' => 0,
15739
                                                                      'uncommit' => undef,
15740
                                                                      'error' => undef,
15741
                                                                      'patcount' => 1,
15742
                                                                      'actcount' => 1,
15743
                                                                      'items' => [
15744
                                                                                   bless( {
15745
                                                                                            'pattern' => '^NIL',
15746
                                                                                            'hashname' => '__PATTERN1__',
15747
                                                                                            'description' => '/^NIL/i',
15748
                                                                                            'lookahead' => 0,
15749
                                                                                            'rdelim' => '/',
15750
                                                                                            'line' => 17,
15751
                                                                                            'mod' => 'i',
15752
                                                                                            'ldelim' => '/'
15753
                                                                                          }, 'Parse::RecDescent::Token' ),
15754
                                                                                   bless( {
15755
                                                                                            'hashname' => '__ACTION1__',
15756
                                                                                            'lookahead' => 0,
15757
                                                                                            'line' => 17,
15758
                                                                                            'code' => '{ $return = "NIL" 	}'
15759
                                                                                          }, 'Parse::RecDescent::Action' )
15760
                                                                                 ],
15761
                                                                      'line' => undef
15762
                                                                    }, 'Parse::RecDescent::Production' )
15763
                                                           ],
15764
                                                'name' => 'NIL',
15765
                                                'vars' => '',
15766
                                                'line' => 17
15767
                                              }, 'Parse::RecDescent::Rule' ),
15768
                              'from' => bless( {
15769
                                                 'impcount' => 0,
15770
                                                 'calls' => [
15771
                                                              'NIL',
15772
                                                              'addressstruct'
15773
                                                            ],
15774
                                                 'changed' => 0,
15775
                                                 'opcount' => 0,
15776
                                                 'prods' => [
15777
                                                              bless( {
15778
                                                                       'number' => '0',
15779
                                                                       'strcount' => 0,
15780
                                                                       'dircount' => 0,
15781
                                                                       'uncommit' => undef,
15782
                                                                       'error' => undef,
15783
                                                                       'patcount' => 0,
15784
                                                                       'actcount' => 0,
15785
                                                                       'items' => [
15786
                                                                                    bless( {
15787
                                                                                             'subrule' => 'NIL',
15788
                                                                                             'matchrule' => 0,
15789
                                                                                             'implicit' => undef,
15790
                                                                                             'argcode' => undef,
15791
                                                                                             'lookahead' => 0,
15792
                                                                                             'line' => 143
15793
                                                                                           }, 'Parse::RecDescent::Subrule' )
15794
                                                                                  ],
15795
                                                                       'line' => undef
15796
                                                                     }, 'Parse::RecDescent::Production' ),
15797
                                                              bless( {
15798
                                                                       'number' => '1',
15799
                                                                       'strcount' => 2,
15800
                                                                       'dircount' => 0,
15801
                                                                       'uncommit' => undef,
15802
                                                                       'error' => undef,
15803
                                                                       'patcount' => 0,
15804
                                                                       'actcount' => 1,
15805
                                                                       'items' => [
15806
                                                                                    bless( {
15807
                                                                                             'pattern' => '(',
15808
                                                                                             'hashname' => '__STRING1__',
15809
                                                                                             'description' => '\'(\'',
15810
                                                                                             'lookahead' => 0,
15811
                                                                                             'line' => 143
15812
                                                                                           }, 'Parse::RecDescent::InterpLit' ),
15813
                                                                                    bless( {
15814
                                                                                             'subrule' => 'addressstruct',
15815
                                                                                             'expected' => undef,
15816
                                                                                             'min' => 1,
15817
                                                                                             'argcode' => undef,
15818
                                                                                             'max' => 100000000,
15819
                                                                                             'matchrule' => 0,
15820
                                                                                             'repspec' => 's',
15821
                                                                                             'lookahead' => 0,
15822
                                                                                             'line' => 143
15823
                                                                                           }, 'Parse::RecDescent::Repetition' ),
15824
                                                                                    bless( {
15825
                                                                                             'pattern' => ')',
15826
                                                                                             'hashname' => '__STRING2__',
15827
                                                                                             'description' => '\')\'',
15828
                                                                                             'lookahead' => 0,
15829
                                                                                             'line' => 143
15830
                                                                                           }, 'Parse::RecDescent::InterpLit' ),
15831
                                                                                    bless( {
15832
                                                                                             'hashname' => '__ACTION1__',
15833
                                                                                             'lookahead' => 0,
15834
                                                                                             'line' => 144,
15835
                                                                                             'code' => '{ $return = $item{NIL} || $item{\'addressstruct(s)\'} }'
15836
                                                                                           }, 'Parse::RecDescent::Action' )
15837
                                                                                  ],
15838
                                                                       'line' => 143
15839
                                                                     }, 'Parse::RecDescent::Production' )
15840
                                                            ],
15841
                                                 'name' => 'from',
15842
                                                 'vars' => '',
15843
                                                 'line' => 143
15844
                                               }, 'Parse::RecDescent::Rule' ),
15845
                              'bodystructure' => bless( {
15846
                                                          'impcount' => 0,
15847
                                                          'calls' => [
15848
                                                                       'part'
15849
                                                                     ],
15850
                                                          'changed' => 0,
15851
                                                          'opcount' => 0,
15852
                                                          'prods' => [
15853
                                                                       bless( {
15854
                                                                                'number' => '0',
15855
                                                                                'strcount' => 2,
15856
                                                                                'dircount' => 0,
15857
                                                                                'uncommit' => undef,
15858
                                                                                'error' => undef,
15859
                                                                                'patcount' => 0,
15860
                                                                                'actcount' => 1,
15861
                                                                                'items' => [
15862
                                                                                             bless( {
15863
                                                                                                      'pattern' => '(',
15864
                                                                                                      'hashname' => '__STRING1__',
15865
                                                                                                      'description' => '\'(\'',
15866
                                                                                                      'lookahead' => 0,
15867
                                                                                                      'line' => 272
15868
                                                                                                    }, 'Parse::RecDescent::InterpLit' ),
15869
                                                                                             bless( {
15870
                                                                                                      'subrule' => 'part',
15871
                                                                                                      'expected' => undef,
15872
                                                                                                      'min' => 1,
15873
                                                                                                      'argcode' => undef,
15874
                                                                                                      'max' => 100000000,
15875
                                                                                                      'matchrule' => 0,
15876
                                                                                                      'repspec' => 's',
15877
                                                                                                      'lookahead' => 0,
15878
                                                                                                      'line' => 272
15879
                                                                                                    }, 'Parse::RecDescent::Repetition' ),
15880
                                                                                             bless( {
15881
                                                                                                      'pattern' => ')',
15882
                                                                                                      'hashname' => '__STRING2__',
15883
                                                                                                      'description' => '\')\'',
15884
                                                                                                      'lookahead' => 0,
15885
                                                                                                      'line' => 272
15886
                                                                                                    }, 'Parse::RecDescent::InterpLit' ),
15887
                                                                                             bless( {
15888
                                                                                                      'hashname' => '__ACTION1__',
15889
                                                                                                      'lookahead' => 0,
15890
                                                                                                      'line' => 273,
15891
                                                                                                      'code' => '{
15892
			$return = $item{\'part(s)\'} ;
15893
			$return||defined($return);
15894
		}'
15895
                                                                                                    }, 'Parse::RecDescent::Action' )
15896
                                                                                           ],
15897
                                                                                'line' => undef
15898
                                                                              }, 'Parse::RecDescent::Production' )
15899
                                                                     ],
15900
                                                          'name' => 'bodystructure',
15901
                                                          'vars' => '',
15902
                                                          'line' => 272
15903
                                                        }, 'Parse::RecDescent::Rule' ),
15904
                              'PLAIN' => bless( {
15905
                                                  'impcount' => 0,
15906
                                                  'calls' => [],
15907
                                                  'changed' => 0,
15908
                                                  'opcount' => 0,
15909
                                                  'prods' => [
15910
                                                               bless( {
15911
                                                                        'number' => '0',
15912
                                                                        'strcount' => 0,
15913
                                                                        'dircount' => 0,
15914
                                                                        'uncommit' => undef,
15915
                                                                        'error' => undef,
15916
                                                                        'patcount' => 1,
15917
                                                                        'actcount' => 1,
15918
                                                                        'items' => [
15919
                                                                                     bless( {
15920
                                                                                              'pattern' => '^"PLAIN"|^PLAIN',
15921
                                                                                              'hashname' => '__PATTERN1__',
15922
                                                                                              'description' => '/^"PLAIN"|^PLAIN/i',
15923
                                                                                              'lookahead' => 0,
15924
                                                                                              'rdelim' => '/',
15925
                                                                                              'line' => 13,
15926
                                                                                              'mod' => 'i',
15927
                                                                                              'ldelim' => '/'
15928
                                                                                            }, 'Parse::RecDescent::Token' ),
15929
                                                                                     bless( {
15930
                                                                                              'hashname' => '__ACTION1__',
15931
                                                                                              'lookahead' => 0,
15932
                                                                                              'line' => 13,
15933
                                                                                              'code' => '{ $return = "PLAIN" }'
15934
                                                                                            }, 'Parse::RecDescent::Action' )
15935
                                                                                   ],
15936
                                                                        'line' => undef
15937
                                                                      }, 'Parse::RecDescent::Production' )
15938
                                                             ],
15939
                                                  'name' => 'PLAIN',
15940
                                                  'vars' => '',
15941
                                                  'line' => 13
15942
                                                }, 'Parse::RecDescent::Rule' ),
15943
                              'NUMBER' => bless( {
15944
                                                   'impcount' => 0,
15945
                                                   'calls' => [],
15946
                                                   'changed' => 0,
15947
                                                   'opcount' => 0,
15948
                                                   'prods' => [
15949
                                                                bless( {
15950
                                                                         'number' => '0',
15951
                                                                         'strcount' => 0,
15952
                                                                         'dircount' => 0,
15953
                                                                         'uncommit' => undef,
15954
                                                                         'error' => undef,
15955
                                                                         'patcount' => 1,
15956
                                                                         'actcount' => 1,
15957
                                                                         'items' => [
15958
                                                                                      bless( {
15959
                                                                                               'pattern' => '^(\\d+)',
15960
                                                                                               'hashname' => '__PATTERN1__',
15961
                                                                                               'description' => '/^(\\\\d+)/',
15962
                                                                                               'lookahead' => 0,
15963
                                                                                               'rdelim' => '/',
15964
                                                                                               'line' => 18,
15965
                                                                                               'mod' => '',
15966
                                                                                               'ldelim' => '/'
15967
                                                                                             }, 'Parse::RecDescent::Token' ),
15968
                                                                                      bless( {
15969
                                                                                               'hashname' => '__ACTION1__',
15970
                                                                                               'lookahead' => 0,
15971
                                                                                               'line' => 18,
15972
                                                                                               'code' => '{ $return = $item[1]; $return||defined($return);}'
15973
                                                                                             }, 'Parse::RecDescent::Action' )
15974
                                                                                    ],
15975
                                                                         'line' => undef
15976
                                                                       }, 'Parse::RecDescent::Production' )
15977
                                                              ],
15978
                                                   'name' => 'NUMBER',
15979
                                                   'vars' => '',
15980
                                                   'line' => 18
15981
                                                 }, 'Parse::RecDescent::Rule' ),
15982
                              'HTML' => bless( {
15983
                                                 'impcount' => 0,
15984
                                                 'calls' => [],
15985
                                                 'changed' => 0,
15986
                                                 'opcount' => 0,
15987
                                                 'prods' => [
15988
                                                              bless( {
15989
                                                                       'number' => '0',
15990
                                                                       'strcount' => 0,
15991
                                                                       'dircount' => 0,
15992
                                                                       'uncommit' => undef,
15993
                                                                       'error' => undef,
15994
                                                                       'patcount' => 1,
15995
                                                                       'actcount' => 1,
15996
                                                                       'items' => [
15997
                                                                                    bless( {
15998
                                                                                             'pattern' => '"HTML"|HTML',
15999
                                                                                             'hashname' => '__PATTERN1__',
16000
                                                                                             'description' => '/"HTML"|HTML/i',
16001
                                                                                             'lookahead' => 0,
16002
                                                                                             'rdelim' => '/',
16003
                                                                                             'line' => 14,
16004
                                                                                             'mod' => 'i',
16005
                                                                                             'ldelim' => '/'
16006
                                                                                           }, 'Parse::RecDescent::Token' ),
16007
                                                                                    bless( {
16008
                                                                                             'hashname' => '__ACTION1__',
16009
                                                                                             'lookahead' => 0,
16010
                                                                                             'line' => 14,
16011
                                                                                             'code' => '{ $return = "HTML" }'
16012
                                                                                           }, 'Parse::RecDescent::Action' )
16013
                                                                                  ],
16014
                                                                       'line' => undef
16015
                                                                     }, 'Parse::RecDescent::Production' )
16016
                                                            ],
16017
                                                 'name' => 'HTML',
16018
                                                 'vars' => '',
16019
                                                 'line' => 14
16020
                                               }, 'Parse::RecDescent::Rule' ),
16021
                              'bodydisp' => bless( {
16022
                                                     'impcount' => 0,
16023
                                                     'calls' => [
16024
                                                                  'NIL',
16025
                                                                  'kvpair'
16026
                                                                ],
16027
                                                     'changed' => 0,
16028
                                                     'opcount' => 0,
16029
                                                     'prods' => [
16030
                                                                  bless( {
16031
                                                                           'number' => '0',
16032
                                                                           'strcount' => 0,
16033
                                                                           'dircount' => 0,
16034
                                                                           'uncommit' => undef,
16035
                                                                           'error' => undef,
16036
                                                                           'patcount' => 0,
16037
                                                                           'actcount' => 0,
16038
                                                                           'items' => [
16039
                                                                                        bless( {
16040
                                                                                                 'subrule' => 'NIL',
16041
                                                                                                 'matchrule' => 0,
16042
                                                                                                 'implicit' => undef,
16043
                                                                                                 'argcode' => undef,
16044
                                                                                                 'lookahead' => 0,
16045
                                                                                                 'line' => 82
16046
                                                                                               }, 'Parse::RecDescent::Subrule' )
16047
                                                                                      ],
16048
                                                                           'line' => undef
16049
                                                                         }, 'Parse::RecDescent::Production' ),
16050
                                                                  bless( {
16051
                                                                           'number' => '1',
16052
                                                                           'strcount' => 2,
16053
                                                                           'dircount' => 0,
16054
                                                                           'uncommit' => undef,
16055
                                                                           'error' => undef,
16056
                                                                           'patcount' => 0,
16057
                                                                           'actcount' => 1,
16058
                                                                           'items' => [
16059
                                                                                        bless( {
16060
                                                                                                 'pattern' => '(',
16061
                                                                                                 'hashname' => '__STRING1__',
16062
                                                                                                 'description' => '\'(\'',
16063
                                                                                                 'lookahead' => 0,
16064
                                                                                                 'line' => 82
16065
                                                                                               }, 'Parse::RecDescent::Literal' ),
16066
                                                                                        bless( {
16067
                                                                                                 'subrule' => 'kvpair',
16068
                                                                                                 'expected' => undef,
16069
                                                                                                 'min' => 1,
16070
                                                                                                 'argcode' => undef,
16071
                                                                                                 'max' => 100000000,
16072
                                                                                                 'matchrule' => 0,
16073
                                                                                                 'repspec' => 's',
16074
                                                                                                 'lookahead' => 0,
16075
                                                                                                 'line' => 82
16076
                                                                                               }, 'Parse::RecDescent::Repetition' ),
16077
                                                                                        bless( {
16078
                                                                                                 'pattern' => ')',
16079
                                                                                                 'hashname' => '__STRING2__',
16080
                                                                                                 'description' => '\')\'',
16081
                                                                                                 'lookahead' => 0,
16082
                                                                                                 'line' => 82
16083
                                                                                               }, 'Parse::RecDescent::Literal' ),
16084
                                                                                        bless( {
16085
                                                                                                 'hashname' => '__ACTION1__',
16086
                                                                                                 'lookahead' => 0,
16087
                                                                                                 'line' => 83,
16088
                                                                                                 'code' => '{
16089
                          $return = $item{NIL} || 
16090
                                    { map { (%$_) } @{$item{\'kvpair(s)\'}} };
16091
                          $return || defined($return); 
16092
                        }'
16093
                                                                                               }, 'Parse::RecDescent::Action' )
16094
                                                                                      ],
16095
                                                                           'line' => 82
16096
                                                                         }, 'Parse::RecDescent::Production' )
16097
                                                                ],
16098
                                                     'name' => 'bodydisp',
16099
                                                     'vars' => '',
16100
                                                     'line' => 82
16101
                                                   }, 'Parse::RecDescent::Rule' ),
16102
                              'part' => bless( {
16103
                                                 'impcount' => 0,
16104
                                                 'calls' => [
16105
                                                              'subpart',
16106
                                                              'basicfields',
16107
                                                              'bodyparms',
16108
                                                              'bodydisp',
16109
                                                              'bodylang',
16110
                                                              'textmessage',
16111
                                                              'messagerfc822message',
16112
                                                              'othertypemessage'
16113
                                                            ],
16114
                                                 'changed' => 0,
16115
                                                 'opcount' => 0,
16116
                                                 'prods' => [
16117
                                                              bless( {
16118
                                                                       'number' => '0',
16119
                                                                       'strcount' => 0,
16120
                                                                       'dircount' => 2,
16121
                                                                       'uncommit' => undef,
16122
                                                                       'error' => undef,
16123
                                                                       'patcount' => 0,
16124
                                                                       'actcount' => 1,
16125
                                                                       'items' => [
16126
                                                                                    bless( {
16127
                                                                                             'subrule' => 'subpart',
16128
                                                                                             'expected' => undef,
16129
                                                                                             'min' => 1,
16130
                                                                                             'argcode' => undef,
16131
                                                                                             'max' => 100000000,
16132
                                                                                             'matchrule' => 0,
16133
                                                                                             'repspec' => 's',
16134
                                                                                             'lookahead' => 0,
16135
                                                                                             'line' => 242
16136
                                                                                           }, 'Parse::RecDescent::Repetition' ),
16137
                                                                                    bless( {
16138
                                                                                             'hashname' => '__DIRECTIVE1__',
16139
                                                                                             'name' => '<commit>',
16140
                                                                                             'lookahead' => 0,
16141
                                                                                             'line' => 242,
16142
                                                                                             'code' => '$commit = 1'
16143
                                                                                           }, 'Parse::RecDescent::Directive' ),
16144
                                                                                    bless( {
16145
                                                                                             'subrule' => 'basicfields',
16146
                                                                                             'matchrule' => 0,
16147
                                                                                             'implicit' => undef,
16148
                                                                                             'argcode' => undef,
16149
                                                                                             'lookahead' => 0,
16150
                                                                                             'line' => 242
16151
                                                                                           }, 'Parse::RecDescent::Subrule' ),
16152
                                                                                    bless( {
16153
                                                                                             'subrule' => 'bodyparms',
16154
                                                                                             'expected' => undef,
16155
                                                                                             'min' => 0,
16156
                                                                                             'argcode' => undef,
16157
                                                                                             'max' => 1,
16158
                                                                                             'matchrule' => 0,
16159
                                                                                             'repspec' => '?',
16160
                                                                                             'lookahead' => 0,
16161
                                                                                             'line' => 243
16162
                                                                                           }, 'Parse::RecDescent::Repetition' ),
16163
                                                                                    bless( {
16164
                                                                                             'subrule' => 'bodydisp',
16165
                                                                                             'expected' => undef,
16166
                                                                                             'min' => 0,
16167
                                                                                             'argcode' => undef,
16168
                                                                                             'max' => 1,
16169
                                                                                             'matchrule' => 0,
16170
                                                                                             'repspec' => '?',
16171
                                                                                             'lookahead' => 0,
16172
                                                                                             'line' => 243
16173
                                                                                           }, 'Parse::RecDescent::Repetition' ),
16174
                                                                                    bless( {
16175
                                                                                             'subrule' => 'bodylang',
16176
                                                                                             'expected' => undef,
16177
                                                                                             'min' => 0,
16178
                                                                                             'argcode' => undef,
16179
                                                                                             'max' => 1,
16180
                                                                                             'matchrule' => 0,
16181
                                                                                             'repspec' => '?',
16182
                                                                                             'lookahead' => 0,
16183
                                                                                             'line' => 243
16184
                                                                                           }, 'Parse::RecDescent::Repetition' ),
16185
                                                                                    bless( {
16186
                                                                                             'hashname' => '__DIRECTIVE2__',
16187
                                                                                             'name' => '<defer:{  $subpartCount = 0 }>',
16188
                                                                                             'lookahead' => 0,
16189
                                                                                             'line' => 244,
16190
                                                                                             'code' => 'push @{$thisparser->{deferred}}, sub {  $subpartCount = 0 };'
16191
                                                                                           }, 'Parse::RecDescent::Directive' ),
16192
                                                                                    bless( {
16193
                                                                                             'hashname' => '__ACTION1__',
16194
                                                                                             'lookahead' => 0,
16195
                                                                                             'line' => 245,
16196
                                                                                             'code' => '{
16197
		$return = bless($item{basicfields}, 
16198
			"Mail::IMAPClient::BodyStructure");
16199
		$return->{bodytype} = "MULTIPART";
16200
		$return->{bodystructure} = $item{\'subpart(s)\'};
16201
		foreach my $b (qw/bodyparms(?) bodydisp(?) bodylang(?)/) { 
16202
			my $k = $b; $k =~ s/\\(\\?\\)$//;
16203
			$return->{$k} = ref($item{$b}) ? $item{$b}[0] : $item{$b};
16204
		}
16205
		$return||defined($return) ;
16206
	}'
16207
                                                                                           }, 'Parse::RecDescent::Action' )
16208
                                                                                  ],
16209
                                                                       'line' => undef
16210
                                                                     }, 'Parse::RecDescent::Production' ),
16211
                                                              bless( {
16212
                                                                       'number' => '1',
16213
                                                                       'strcount' => 0,
16214
                                                                       'dircount' => 0,
16215
                                                                       'uncommit' => undef,
16216
                                                                       'error' => undef,
16217
                                                                       'patcount' => 0,
16218
                                                                       'actcount' => 1,
16219
                                                                       'items' => [
16220
                                                                                    bless( {
16221
                                                                                             'subrule' => 'textmessage',
16222
                                                                                             'matchrule' => 0,
16223
                                                                                             'implicit' => undef,
16224
                                                                                             'argcode' => undef,
16225
                                                                                             'lookahead' => 0,
16226
                                                                                             'line' => 256
16227
                                                                                           }, 'Parse::RecDescent::Subrule' ),
16228
                                                                                    bless( {
16229
                                                                                             'hashname' => '__ACTION1__',
16230
                                                                                             'lookahead' => 0,
16231
                                                                                             'line' => 257,
16232
                                                                                             'code' => '{
16233
		$return = bless $item{textmessage}, "Mail::IMAPClient::BodyStructure";
16234
		$return||defined($return);
16235
	}'
16236
                                                                                           }, 'Parse::RecDescent::Action' )
16237
                                                                                  ],
16238
                                                                       'line' => 256
16239
                                                                     }, 'Parse::RecDescent::Production' ),
16240
                                                              bless( {
16241
                                                                       'number' => '2',
16242
                                                                       'strcount' => 0,
16243
                                                                       'dircount' => 0,
16244
                                                                       'uncommit' => undef,
16245
                                                                       'error' => undef,
16246
                                                                       'patcount' => 0,
16247
                                                                       'actcount' => 1,
16248
                                                                       'items' => [
16249
                                                                                    bless( {
16250
                                                                                             'subrule' => 'messagerfc822message',
16251
                                                                                             'matchrule' => 0,
16252
                                                                                             'implicit' => undef,
16253
                                                                                             'argcode' => undef,
16254
                                                                                             'lookahead' => 0,
16255
                                                                                             'line' => 261
16256
                                                                                           }, 'Parse::RecDescent::Subrule' ),
16257
                                                                                    bless( {
16258
                                                                                             'hashname' => '__ACTION1__',
16259
                                                                                             'lookahead' => 0,
16260
                                                                                             'line' => 262,
16261
                                                                                             'code' => '{
16262
		$return = bless $item{messagerfc822message}, "Mail::IMAPClient::BodyStructure";
16263
		$return||defined($return);
16264
	}'
16265
                                                                                           }, 'Parse::RecDescent::Action' )
16266
                                                                                  ],
16267
                                                                       'line' => 261
16268
                                                                     }, 'Parse::RecDescent::Production' ),
16269
                                                              bless( {
16270
                                                                       'number' => '3',
16271
                                                                       'strcount' => 0,
16272
                                                                       'dircount' => 0,
16273
                                                                       'uncommit' => undef,
16274
                                                                       'error' => undef,
16275
                                                                       'patcount' => 0,
16276
                                                                       'actcount' => 1,
16277
                                                                       'items' => [
16278
                                                                                    bless( {
16279
                                                                                             'subrule' => 'othertypemessage',
16280
                                                                                             'matchrule' => 0,
16281
                                                                                             'implicit' => undef,
16282
                                                                                             'argcode' => undef,
16283
                                                                                             'lookahead' => 0,
16284
                                                                                             'line' => 266
16285
                                                                                           }, 'Parse::RecDescent::Subrule' ),
16286
                                                                                    bless( {
16287
                                                                                             'hashname' => '__ACTION1__',
16288
                                                                                             'lookahead' => 0,
16289
                                                                                             'line' => 267,
16290
                                                                                             'code' => '{
16291
		$return = bless $item{othertypemessage}, "Mail::IMAPClient::BodyStructure";
16292
		$return||defined($return);
16293
	}'
16294
                                                                                           }, 'Parse::RecDescent::Action' )
16295
                                                                                  ],
16296
                                                                       'line' => 266
16297
                                                                     }, 'Parse::RecDescent::Production' )
16298
                                                            ],
16299
                                                 'name' => 'part',
16300
                                                 'vars' => '',
16301
                                                 'line' => 242
16302
                                               }, 'Parse::RecDescent::Rule' ),
16303
                              'SINGLE_QUOTED_STRING' => bless( {
16304
                                                                 'impcount' => 0,
16305
                                                                 'calls' => [],
16306
                                                                 'changed' => 0,
16307
                                                                 'opcount' => 0,
16308
                                                                 'prods' => [
16309
                                                                              bless( {
16310
                                                                                       'number' => '0',
16311
                                                                                       'strcount' => 2,
16312
                                                                                       'dircount' => 0,
16313
                                                                                       'uncommit' => undef,
16314
                                                                                       'error' => undef,
16315
                                                                                       'patcount' => 1,
16316
                                                                                       'actcount' => 1,
16317
                                                                                       'items' => [
16318
                                                                                                    bless( {
16319
                                                                                                             'pattern' => '\'',
16320
                                                                                                             'hashname' => '__STRING1__',
16321
                                                                                                             'description' => '\'\'\'',
16322
                                                                                                             'lookahead' => 0,
16323
                                                                                                             'line' => 22
16324
                                                                                                           }, 'Parse::RecDescent::InterpLit' ),
16325
                                                                                                    bless( {
16326
                                                                                                             'pattern' => '(?:\\\\\'|[^\'])*',
16327
                                                                                                             'hashname' => '__PATTERN1__',
16328
                                                                                                             'description' => '/(?:\\\\\\\\\'|[^\'])*/',
16329
                                                                                                             'lookahead' => 0,
16330
                                                                                                             'rdelim' => '/',
16331
                                                                                                             'line' => 22,
16332
                                                                                                             'mod' => '',
16333
                                                                                                             'ldelim' => '/'
16334
                                                                                                           }, 'Parse::RecDescent::Token' ),
16335
                                                                                                    bless( {
16336
                                                                                                             'pattern' => '\'',
16337
                                                                                                             'hashname' => '__STRING2__',
16338
                                                                                                             'description' => '\'\'\'',
16339
                                                                                                             'lookahead' => 0,
16340
                                                                                                             'line' => 22
16341
                                                                                                           }, 'Parse::RecDescent::InterpLit' ),
16342
                                                                                                    bless( {
16343
                                                                                                             'hashname' => '__ACTION1__',
16344
                                                                                                             'lookahead' => 0,
16345
                                                                                                             'line' => 22,
16346
                                                                                                             'code' => '{
16347
 
16348
	$return = $item{__PATTERN1__} ;
16349
	$return||defined($return);
16350
}'
16351
                                                                                                           }, 'Parse::RecDescent::Action' )
16352
                                                                                                  ],
16353
                                                                                       'line' => undef
16354
                                                                                     }, 'Parse::RecDescent::Production' )
16355
                                                                            ],
16356
                                                                 'name' => 'SINGLE_QUOTED_STRING',
16357
                                                                 'vars' => '',
16358
                                                                 'line' => 20
16359
                                                               }, 'Parse::RecDescent::Rule' ),
16360
                              'bcc' => bless( {
16361
                                                'impcount' => 0,
16362
                                                'calls' => [
16363
                                                             'NIL',
16364
                                                             'addressstruct'
16365
                                                           ],
16366
                                                'changed' => 0,
16367
                                                'opcount' => 0,
16368
                                                'prods' => [
16369
                                                             bless( {
16370
                                                                      'number' => '0',
16371
                                                                      'strcount' => 0,
16372
                                                                      'dircount' => 0,
16373
                                                                      'uncommit' => undef,
16374
                                                                      'error' => undef,
16375
                                                                      'patcount' => 0,
16376
                                                                      'actcount' => 0,
16377
                                                                      'items' => [
16378
                                                                                   bless( {
16379
                                                                                            'subrule' => 'NIL',
16380
                                                                                            'matchrule' => 0,
16381
                                                                                            'implicit' => undef,
16382
                                                                                            'argcode' => undef,
16383
                                                                                            'lookahead' => 0,
16384
                                                                                            'line' => 140
16385
                                                                                          }, 'Parse::RecDescent::Subrule' )
16386
                                                                                 ],
16387
                                                                      'line' => undef
16388
                                                                    }, 'Parse::RecDescent::Production' ),
16389
                                                             bless( {
16390
                                                                      'number' => '1',
16391
                                                                      'strcount' => 2,
16392
                                                                      'dircount' => 0,
16393
                                                                      'uncommit' => undef,
16394
                                                                      'error' => undef,
16395
                                                                      'patcount' => 0,
16396
                                                                      'actcount' => 1,
16397
                                                                      'items' => [
16398
                                                                                   bless( {
16399
                                                                                            'pattern' => '(',
16400
                                                                                            'hashname' => '__STRING1__',
16401
                                                                                            'description' => '\'(\'',
16402
                                                                                            'lookahead' => 0,
16403
                                                                                            'line' => 140
16404
                                                                                          }, 'Parse::RecDescent::InterpLit' ),
16405
                                                                                   bless( {
16406
                                                                                            'subrule' => 'addressstruct',
16407
                                                                                            'expected' => undef,
16408
                                                                                            'min' => 1,
16409
                                                                                            'argcode' => undef,
16410
                                                                                            'max' => 100000000,
16411
                                                                                            'matchrule' => 0,
16412
                                                                                            'repspec' => 's',
16413
                                                                                            'lookahead' => 0,
16414
                                                                                            'line' => 140
16415
                                                                                          }, 'Parse::RecDescent::Repetition' ),
16416
                                                                                   bless( {
16417
                                                                                            'pattern' => ')',
16418
                                                                                            'hashname' => '__STRING2__',
16419
                                                                                            'description' => '\')\'',
16420
                                                                                            'lookahead' => 0,
16421
                                                                                            'line' => 140
16422
                                                                                          }, 'Parse::RecDescent::InterpLit' ),
16423
                                                                                   bless( {
16424
                                                                                            'hashname' => '__ACTION1__',
16425
                                                                                            'lookahead' => 0,
16426
                                                                                            'line' => 141,
16427
                                                                                            'code' => '{ $return = $item{NIL} || $item{\'addressstruct(s)\'} }'
16428
                                                                                          }, 'Parse::RecDescent::Action' )
16429
                                                                                 ],
16430
                                                                      'line' => 140
16431
                                                                    }, 'Parse::RecDescent::Production' )
16432
                                                           ],
16433
                                                'name' => 'bcc',
16434
                                                'vars' => '',
16435
                                                'line' => 140
16436
                                              }, 'Parse::RecDescent::Rule' ),
16437
                              'rfc822message' => bless( {
16438
                                                          'impcount' => 0,
16439
                                                          'calls' => [
16440
                                                                       'MESSAGE',
16441
                                                                       'RFC822'
16442
                                                                     ],
16443
                                                          'changed' => 0,
16444
                                                          'opcount' => 0,
16445
                                                          'prods' => [
16446
                                                                       bless( {
16447
                                                                                'number' => '0',
16448
                                                                                'strcount' => 0,
16449
                                                                                'dircount' => 0,
16450
                                                                                'uncommit' => undef,
16451
                                                                                'error' => undef,
16452
                                                                                'patcount' => 0,
16453
                                                                                'actcount' => 1,
16454
                                                                                'items' => [
16455
                                                                                             bless( {
16456
                                                                                                      'subrule' => 'MESSAGE',
16457
                                                                                                      'matchrule' => 0,
16458
                                                                                                      'implicit' => undef,
16459
                                                                                                      'argcode' => undef,
16460
                                                                                                      'lookahead' => 0,
16461
                                                                                                      'line' => 59
16462
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
16463
                                                                                             bless( {
16464
                                                                                                      'subrule' => 'RFC822',
16465
                                                                                                      'matchrule' => 0,
16466
                                                                                                      'implicit' => undef,
16467
                                                                                                      'argcode' => undef,
16468
                                                                                                      'lookahead' => 0,
16469
                                                                                                      'line' => 59
16470
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
16471
                                                                                             bless( {
16472
                                                                                                      'hashname' => '__ACTION1__',
16473
                                                                                                      'lookahead' => 0,
16474
                                                                                                      'line' => 59,
16475
                                                                                                      'code' => '{ $return = "MESSAGE RFC822" }'
16476
                                                                                                    }, 'Parse::RecDescent::Action' )
16477
                                                                                           ],
16478
                                                                                'line' => undef
16479
                                                                              }, 'Parse::RecDescent::Production' )
16480
                                                                     ],
16481
                                                          'name' => 'rfc822message',
16482
                                                          'vars' => '',
16483
                                                          'line' => 59
16484
                                                        }, 'Parse::RecDescent::Rule' ),
16485
                              'OLDSTRING' => bless( {
16486
                                                      'impcount' => 0,
16487
                                                      'calls' => [],
16488
                                                      'changed' => 0,
16489
                                                      'opcount' => 0,
16490
                                                      'prods' => [
16491
                                                                   bless( {
16492
                                                                            'number' => '0',
16493
                                                                            'strcount' => 0,
16494
                                                                            'dircount' => 0,
16495
                                                                            'uncommit' => undef,
16496
                                                                            'error' => undef,
16497
                                                                            'patcount' => 1,
16498
                                                                            'actcount' => 0,
16499
                                                                            'items' => [
16500
                                                                                         bless( {
16501
                                                                                                  'pattern' => '^"((?:[^"\\\\]|\\\\.)*)"',
16502
                                                                                                  'hashname' => '__PATTERN1__',
16503
                                                                                                  'description' => '/^"((?:[^"\\\\\\\\]|\\\\\\\\.)*)"/',
16504
                                                                                                  'lookahead' => 0,
16505
                                                                                                  'rdelim' => '/',
16506
                                                                                                  'line' => 49,
16507
                                                                                                  'mod' => '',
16508
                                                                                                  'ldelim' => '/'
16509
                                                                                                }, 'Parse::RecDescent::Token' )
16510
                                                                                       ],
16511
                                                                            'line' => undef
16512
                                                                          }, 'Parse::RecDescent::Production' ),
16513
                                                                   bless( {
16514
                                                                            'number' => '1',
16515
                                                                            'strcount' => 0,
16516
                                                                            'dircount' => 0,
16517
                                                                            'uncommit' => undef,
16518
                                                                            'error' => undef,
16519
                                                                            'patcount' => 1,
16520
                                                                            'actcount' => 1,
16521
                                                                            'items' => [
16522
                                                                                         bless( {
16523
                                                                                                  'pattern' => '^([^ \\(\\)]+)',
16524
                                                                                                  'hashname' => '__PATTERN1__',
16525
                                                                                                  'description' => '/^([^ \\\\(\\\\)]+)/',
16526
                                                                                                  'lookahead' => 0,
16527
                                                                                                  'rdelim' => '/',
16528
                                                                                                  'line' => 49,
16529
                                                                                                  'mod' => '',
16530
                                                                                                  'ldelim' => '/'
16531
                                                                                                }, 'Parse::RecDescent::Token' ),
16532
                                                                                         bless( {
16533
                                                                                                  'hashname' => '__ACTION1__',
16534
                                                                                                  'lookahead' => 0,
16535
                                                                                                  'line' => 50,
16536
                                                                                                  'code' => '{       $item{__PATTERN1__} =~ s/^"(.*)"$/$1/;
16537
                                $return = $item{__PATTERN1__} || $item{__PATTERN2__} ;
16538
                                $return||defined($return);
16539
                        }'
16540
                                                                                                }, 'Parse::RecDescent::Action' )
16541
                                                                                       ],
16542
                                                                            'line' => 49
16543
                                                                          }, 'Parse::RecDescent::Production' )
16544
                                                                 ],
16545
                                                      'name' => 'OLDSTRING',
16546
                                                      'vars' => '',
16547
                                                      'line' => 49
16548
                                                    }, 'Parse::RecDescent::Rule' ),
16549
                              'addressstruct' => bless( {
16550
                                                          'impcount' => 0,
16551
                                                          'calls' => [
16552
                                                                       'personalname',
16553
                                                                       'sourceroute',
16554
                                                                       'mailboxname',
16555
                                                                       'hostname'
16556
                                                                     ],
16557
                                                          'changed' => 0,
16558
                                                          'opcount' => 0,
16559
                                                          'prods' => [
16560
                                                                       bless( {
16561
                                                                                'number' => '0',
16562
                                                                                'strcount' => 2,
16563
                                                                                'dircount' => 0,
16564
                                                                                'uncommit' => undef,
16565
                                                                                'error' => undef,
16566
                                                                                'patcount' => 0,
16567
                                                                                'actcount' => 1,
16568
                                                                                'items' => [
16569
                                                                                             bless( {
16570
                                                                                                      'pattern' => '(',
16571
                                                                                                      'hashname' => '__STRING1__',
16572
                                                                                                      'description' => '\'(\'',
16573
                                                                                                      'lookahead' => 0,
16574
                                                                                                      'line' => 114
16575
                                                                                                    }, 'Parse::RecDescent::InterpLit' ),
16576
                                                                                             bless( {
16577
                                                                                                      'subrule' => 'personalname',
16578
                                                                                                      'matchrule' => 0,
16579
                                                                                                      'implicit' => undef,
16580
                                                                                                      'argcode' => undef,
16581
                                                                                                      'lookahead' => 0,
16582
                                                                                                      'line' => 114
16583
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
16584
                                                                                             bless( {
16585
                                                                                                      'subrule' => 'sourceroute',
16586
                                                                                                      'matchrule' => 0,
16587
                                                                                                      'implicit' => undef,
16588
                                                                                                      'argcode' => undef,
16589
                                                                                                      'lookahead' => 0,
16590
                                                                                                      'line' => 114
16591
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
16592
                                                                                             bless( {
16593
                                                                                                      'subrule' => 'mailboxname',
16594
                                                                                                      'matchrule' => 0,
16595
                                                                                                      'implicit' => undef,
16596
                                                                                                      'argcode' => undef,
16597
                                                                                                      'lookahead' => 0,
16598
                                                                                                      'line' => 114
16599
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
16600
                                                                                             bless( {
16601
                                                                                                      'subrule' => 'hostname',
16602
                                                                                                      'matchrule' => 0,
16603
                                                                                                      'implicit' => undef,
16604
                                                                                                      'argcode' => undef,
16605
                                                                                                      'lookahead' => 0,
16606
                                                                                                      'line' => 114
16607
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
16608
                                                                                             bless( {
16609
                                                                                                      'pattern' => ')',
16610
                                                                                                      'hashname' => '__STRING2__',
16611
                                                                                                      'description' => '\')\'',
16612
                                                                                                      'lookahead' => 0,
16613
                                                                                                      'line' => 114
16614
                                                                                                    }, 'Parse::RecDescent::InterpLit' ),
16615
                                                                                             bless( {
16616
                                                                                                      'hashname' => '__ACTION1__',
16617
                                                                                                      'lookahead' => 0,
16618
                                                                                                      'line' => 115,
16619
                                                                                                      'code' => '{ $return = {
16620
			personalname => $item{personalname} ,	
16621
			sourceroute  => $item{sourceroute} ,	
16622
			mailboxname  => $item{mailboxname} ,	
16623
			hostname     => $item{hostname} ,	
16624
		  } ;
16625
		  bless($return, "Mail::IMAPClient::BodyStructure::Address");
16626
		}'
16627
                                                                                                    }, 'Parse::RecDescent::Action' )
16628
                                                                                           ],
16629
                                                                                'line' => undef
16630
                                                                              }, 'Parse::RecDescent::Production' )
16631
                                                                     ],
16632
                                                          'name' => 'addressstruct',
16633
                                                          'vars' => '',
16634
                                                          'line' => 114
16635
                                                        }, 'Parse::RecDescent::Rule' ),
16636
                              'sourceroute' => bless( {
16637
                                                        'impcount' => 0,
16638
                                                        'calls' => [
16639
                                                                     'NIL',
16640
                                                                     'STRING'
16641
                                                                   ],
16642
                                                        'changed' => 0,
16643
                                                        'opcount' => 0,
16644
                                                        'prods' => [
16645
                                                                     bless( {
16646
                                                                              'number' => '0',
16647
                                                                              'strcount' => 0,
16648
                                                                              'dircount' => 0,
16649
                                                                              'uncommit' => undef,
16650
                                                                              'error' => undef,
16651
                                                                              'patcount' => 0,
16652
                                                                              'actcount' => 0,
16653
                                                                              'items' => [
16654
                                                                                           bless( {
16655
                                                                                                    'subrule' => 'NIL',
16656
                                                                                                    'matchrule' => 0,
16657
                                                                                                    'implicit' => undef,
16658
                                                                                                    'argcode' => undef,
16659
                                                                                                    'lookahead' => 0,
16660
                                                                                                    'line' => 108
16661
                                                                                                  }, 'Parse::RecDescent::Subrule' )
16662
                                                                                         ],
16663
                                                                              'line' => undef
16664
                                                                            }, 'Parse::RecDescent::Production' ),
16665
                                                                     bless( {
16666
                                                                              'number' => '1',
16667
                                                                              'strcount' => 0,
16668
                                                                              'dircount' => 0,
16669
                                                                              'uncommit' => undef,
16670
                                                                              'error' => undef,
16671
                                                                              'patcount' => 0,
16672
                                                                              'actcount' => 1,
16673
                                                                              'items' => [
16674
                                                                                           bless( {
16675
                                                                                                    'subrule' => 'STRING',
16676
                                                                                                    'matchrule' => 0,
16677
                                                                                                    'implicit' => undef,
16678
                                                                                                    'argcode' => undef,
16679
                                                                                                    'lookahead' => 0,
16680
                                                                                                    'line' => 108
16681
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
16682
                                                                                           bless( {
16683
                                                                                                    'hashname' => '__ACTION1__',
16684
                                                                                                    'lookahead' => 0,
16685
                                                                                                    'line' => 109,
16686
                                                                                                    'code' => '{ $return = $item{NIL} || $item{STRING} ;$return||defined($return);}'
16687
                                                                                                  }, 'Parse::RecDescent::Action' )
16688
                                                                                         ],
16689
                                                                              'line' => 108
16690
                                                                            }, 'Parse::RecDescent::Production' )
16691
                                                                   ],
16692
                                                        'name' => 'sourceroute',
16693
                                                        'vars' => '',
16694
                                                        'line' => 108
16695
                                                      }, 'Parse::RecDescent::Rule' ),
16696
                              'subpart' => bless( {
16697
                                                    'impcount' => 0,
16698
                                                    'calls' => [
16699
                                                                 'part'
16700
                                                               ],
16701
                                                    'changed' => 0,
16702
                                                    'opcount' => 0,
16703
                                                    'prods' => [
16704
                                                                 bless( {
16705
                                                                          'number' => '0',
16706
                                                                          'strcount' => 2,
16707
                                                                          'dircount' => 1,
16708
                                                                          'uncommit' => undef,
16709
                                                                          'error' => undef,
16710
                                                                          'patcount' => 0,
16711
                                                                          'actcount' => 1,
16712
                                                                          'items' => [
16713
                                                                                       bless( {
16714
                                                                                                'pattern' => '(',
16715
                                                                                                'hashname' => '__STRING1__',
16716
                                                                                                'description' => '\'(\'',
16717
                                                                                                'lookahead' => 0,
16718
                                                                                                'line' => 235
16719
                                                                                              }, 'Parse::RecDescent::InterpLit' ),
16720
                                                                                       bless( {
16721
                                                                                                'subrule' => 'part',
16722
                                                                                                'matchrule' => 0,
16723
                                                                                                'implicit' => undef,
16724
                                                                                                'argcode' => undef,
16725
                                                                                                'lookahead' => 0,
16726
                                                                                                'line' => 235
16727
                                                                                              }, 'Parse::RecDescent::Subrule' ),
16728
                                                                                       bless( {
16729
                                                                                                'pattern' => ')',
16730
                                                                                                'hashname' => '__STRING2__',
16731
                                                                                                'description' => '\')\'',
16732
                                                                                                'lookahead' => 0,
16733
                                                                                                'line' => 235
16734
                                                                                              }, 'Parse::RecDescent::InterpLit' ),
16735
                                                                                       bless( {
16736
                                                                                                'hashname' => '__ACTION1__',
16737
                                                                                                'lookahead' => 0,
16738
                                                                                                'line' => 236,
16739
                                                                                                'code' => '{ 
16740
		$return = $item{part} ; 
16741
		$return||defined($return);
16742
	}'
16743
                                                                                              }, 'Parse::RecDescent::Action' ),
16744
                                                                                       bless( {
16745
                                                                                                'hashname' => '__DIRECTIVE1__',
16746
                                                                                                'name' => '<defer:{  ++$subpartCount; }>',
16747
                                                                                                'lookahead' => 0,
16748
                                                                                                'line' => 239,
16749
                                                                                                'code' => 'push @{$thisparser->{deferred}}, sub {  ++$subpartCount; };'
16750
                                                                                              }, 'Parse::RecDescent::Directive' )
16751
                                                                                     ],
16752
                                                                          'line' => undef
16753
                                                                        }, 'Parse::RecDescent::Production' )
16754
                                                               ],
16755
                                                    'name' => 'subpart',
16756
                                                    'vars' => '',
16757
                                                    'line' => 235
16758
                                                  }, 'Parse::RecDescent::Rule' ),
16759
                              'textlines' => bless( {
16760
                                                      'impcount' => 0,
16761
                                                      'calls' => [
16762
                                                                   'NIL',
16763
                                                                   'NUMBER'
16764
                                                                 ],
16765
                                                      'changed' => 0,
16766
                                                      'opcount' => 0,
16767
                                                      'prods' => [
16768
                                                                   bless( {
16769
                                                                            'number' => '0',
16770
                                                                            'strcount' => 0,
16771
                                                                            'dircount' => 0,
16772
                                                                            'uncommit' => undef,
16773
                                                                            'error' => undef,
16774
                                                                            'patcount' => 0,
16775
                                                                            'actcount' => 0,
16776
                                                                            'items' => [
16777
                                                                                         bless( {
16778
                                                                                                  'subrule' => 'NIL',
16779
                                                                                                  'matchrule' => 0,
16780
                                                                                                  'implicit' => undef,
16781
                                                                                                  'argcode' => undef,
16782
                                                                                                  'lookahead' => 0,
16783
                                                                                                  'line' => 58
16784
                                                                                                }, 'Parse::RecDescent::Subrule' )
16785
                                                                                       ],
16786
                                                                            'line' => undef
16787
                                                                          }, 'Parse::RecDescent::Production' ),
16788
                                                                   bless( {
16789
                                                                            'number' => '1',
16790
                                                                            'strcount' => 0,
16791
                                                                            'dircount' => 0,
16792
                                                                            'uncommit' => undef,
16793
                                                                            'error' => undef,
16794
                                                                            'patcount' => 0,
16795
                                                                            'actcount' => 1,
16796
                                                                            'items' => [
16797
                                                                                         bless( {
16798
                                                                                                  'subrule' => 'NUMBER',
16799
                                                                                                  'matchrule' => 0,
16800
                                                                                                  'implicit' => undef,
16801
                                                                                                  'argcode' => undef,
16802
                                                                                                  'lookahead' => 0,
16803
                                                                                                  'line' => 58
16804
                                                                                                }, 'Parse::RecDescent::Subrule' ),
16805
                                                                                         bless( {
16806
                                                                                                  'hashname' => '__ACTION1__',
16807
                                                                                                  'lookahead' => 0,
16808
                                                                                                  'line' => 58,
16809
                                                                                                  'code' => '{ $return = $item[1] || $item[2]; $return||defined($return); }'
16810
                                                                                                }, 'Parse::RecDescent::Action' )
16811
                                                                                       ],
16812
                                                                            'line' => 58
16813
                                                                          }, 'Parse::RecDescent::Production' )
16814
                                                                 ],
16815
                                                      'name' => 'textlines',
16816
                                                      'vars' => '',
16817
                                                      'line' => 56
16818
                                                    }, 'Parse::RecDescent::Rule' ),
16819
                              'BARESTRING' => bless( {
16820
                                                       'impcount' => 0,
16821
                                                       'calls' => [],
16822
                                                       'changed' => 0,
16823
                                                       'opcount' => 0,
16824
                                                       'prods' => [
16825
                                                                    bless( {
16826
                                                                             'number' => '0',
16827
                                                                             'strcount' => 0,
16828
                                                                             'dircount' => 0,
16829
                                                                             'uncommit' => undef,
16830
                                                                             'error' => undef,
16831
                                                                             'patcount' => 2,
16832
                                                                             'actcount' => 1,
16833
                                                                             'items' => [
16834
                                                                                          bless( {
16835
                                                                                                   'pattern' => '^[)(\'"]',
16836
                                                                                                   'hashname' => '__PATTERN1__',
16837
                                                                                                   'description' => '/^[)(\'"]/',
16838
                                                                                                   'lookahead' => -1,
16839
                                                                                                   'rdelim' => '/',
16840
                                                                                                   'line' => 40,
16841
                                                                                                   'mod' => '',
16842
                                                                                                   'ldelim' => '/'
16843
                                                                                                 }, 'Parse::RecDescent::Token' ),
16844
                                                                                          bless( {
16845
                                                                                                   'pattern' => '^(?!\\(|\\))(?:\\\\ |\\S)+',
16846
                                                                                                   'hashname' => '__PATTERN2__',
16847
                                                                                                   'description' => '/^(?!\\\\(|\\\\))(?:\\\\\\\\ |\\\\S)+/',
16848
                                                                                                   'lookahead' => 0,
16849
                                                                                                   'rdelim' => '/',
16850
                                                                                                   'line' => 40,
16851
                                                                                                   'mod' => '',
16852
                                                                                                   'ldelim' => '/'
16853
                                                                                                 }, 'Parse::RecDescent::Token' ),
16854
                                                                                          bless( {
16855
                                                                                                   'hashname' => '__ACTION1__',
16856
                                                                                                   'lookahead' => 0,
16857
                                                                                                   'line' => 40,
16858
                                                                                                   'code' => '{ 
16859
	$return = $item{__PATTERN1__} ; $return||defined($return);
16860
}'
16861
                                                                                                 }, 'Parse::RecDescent::Action' )
16862
                                                                                        ],
16863
                                                                             'line' => undef
16864
                                                                           }, 'Parse::RecDescent::Production' )
16865
                                                                  ],
16866
                                                       'name' => 'BARESTRING',
16867
                                                       'vars' => '',
16868
                                                       'line' => 40
16869
                                                     }, 'Parse::RecDescent::Rule' ),
16870
                              'bodylang' => bless( {
16871
                                                     'impcount' => 0,
16872
                                                     'calls' => [
16873
                                                                  'NIL',
16874
                                                                  'STRING'
16875
                                                                ],
16876
                                                     'changed' => 0,
16877
                                                     'opcount' => 0,
16878
                                                     'prods' => [
16879
                                                                  bless( {
16880
                                                                           'number' => '0',
16881
                                                                           'strcount' => 0,
16882
                                                                           'dircount' => 0,
16883
                                                                           'uncommit' => undef,
16884
                                                                           'error' => undef,
16885
                                                                           'patcount' => 0,
16886
                                                                           'actcount' => 0,
16887
                                                                           'items' => [
16888
                                                                                        bless( {
16889
                                                                                                 'subrule' => 'NIL',
16890
                                                                                                 'matchrule' => 0,
16891
                                                                                                 'implicit' => undef,
16892
                                                                                                 'argcode' => undef,
16893
                                                                                                 'lookahead' => 0,
16894
                                                                                                 'line' => 104
16895
                                                                                               }, 'Parse::RecDescent::Subrule' )
16896
                                                                                      ],
16897
                                                                           'line' => undef
16898
                                                                         }, 'Parse::RecDescent::Production' ),
16899
                                                                  bless( {
16900
                                                                           'number' => '1',
16901
                                                                           'strcount' => 0,
16902
                                                                           'dircount' => 0,
16903
                                                                           'uncommit' => undef,
16904
                                                                           'error' => undef,
16905
                                                                           'patcount' => 0,
16906
                                                                           'actcount' => 0,
16907
                                                                           'items' => [
16908
                                                                                        bless( {
16909
                                                                                                 'subrule' => 'STRING',
16910
                                                                                                 'matchrule' => 0,
16911
                                                                                                 'implicit' => undef,
16912
                                                                                                 'argcode' => undef,
16913
                                                                                                 'lookahead' => 0,
16914
                                                                                                 'line' => 104
16915
                                                                                               }, 'Parse::RecDescent::Subrule' )
16916
                                                                                      ],
16917
                                                                           'line' => 104
16918
                                                                         }, 'Parse::RecDescent::Production' ),
16919
                                                                  bless( {
16920
                                                                           'number' => '2',
16921
                                                                           'strcount' => 2,
16922
                                                                           'dircount' => 0,
16923
                                                                           'uncommit' => undef,
16924
                                                                           'error' => undef,
16925
                                                                           'patcount' => 0,
16926
                                                                           'actcount' => 1,
16927
                                                                           'items' => [
16928
                                                                                        bless( {
16929
                                                                                                 'pattern' => '(',
16930
                                                                                                 'hashname' => '__STRING1__',
16931
                                                                                                 'description' => '\'(\'',
16932
                                                                                                 'lookahead' => 0,
16933
                                                                                                 'line' => 104
16934
                                                                                               }, 'Parse::RecDescent::InterpLit' ),
16935
                                                                                        bless( {
16936
                                                                                                 'subrule' => 'STRING',
16937
                                                                                                 'expected' => undef,
16938
                                                                                                 'min' => 1,
16939
                                                                                                 'argcode' => undef,
16940
                                                                                                 'max' => 100000000,
16941
                                                                                                 'matchrule' => 0,
16942
                                                                                                 'repspec' => 's',
16943
                                                                                                 'lookahead' => 0,
16944
                                                                                                 'line' => 104
16945
                                                                                               }, 'Parse::RecDescent::Repetition' ),
16946
                                                                                        bless( {
16947
                                                                                                 'pattern' => ')',
16948
                                                                                                 'hashname' => '__STRING2__',
16949
                                                                                                 'description' => '\')\'',
16950
                                                                                                 'lookahead' => 0,
16951
                                                                                                 'line' => 104
16952
                                                                                               }, 'Parse::RecDescent::InterpLit' ),
16953
                                                                                        bless( {
16954
                                                                                                 'hashname' => '__ACTION1__',
16955
                                                                                                 'lookahead' => 0,
16956
                                                                                                 'line' => 105,
16957
                                                                                                 'code' => '{ $return = $item{NIL} || $item{\'STRING(s)\'} ;$return||defined($return);}'
16958
                                                                                               }, 'Parse::RecDescent::Action' )
16959
                                                                                      ],
16960
                                                                           'line' => 104
16961
                                                                         }, 'Parse::RecDescent::Production' )
16962
                                                                ],
16963
                                                     'name' => 'bodylang',
16964
                                                     'vars' => '',
16965
                                                     'line' => 104
16966
                                                   }, 'Parse::RecDescent::Rule' ),
16967
                              'envelopestruct' => bless( {
16968
                                                           'impcount' => 0,
16969
                                                           'calls' => [
16970
                                                                        'date',
16971
                                                                        'subject',
16972
                                                                        'from',
16973
                                                                        'sender',
16974
                                                                        'replyto',
16975
                                                                        'to',
16976
                                                                        'cc',
16977
                                                                        'bcc',
16978
                                                                        'inreplyto',
16979
                                                                        'messageid'
16980
                                                                      ],
16981
                                                           'changed' => 0,
16982
                                                           'opcount' => 0,
16983
                                                           'prods' => [
16984
                                                                        bless( {
16985
                                                                                 'number' => '0',
16986
                                                                                 'strcount' => 2,
16987
                                                                                 'dircount' => 0,
16988
                                                                                 'uncommit' => undef,
16989
                                                                                 'error' => undef,
16990
                                                                                 'patcount' => 0,
16991
                                                                                 'actcount' => 1,
16992
                                                                                 'items' => [
16993
                                                                                              bless( {
16994
                                                                                                       'pattern' => '(',
16995
                                                                                                       'hashname' => '__STRING1__',
16996
                                                                                                       'description' => '\'(\'',
16997
                                                                                                       'lookahead' => 0,
16998
                                                                                                       'line' => 155
16999
                                                                                                     }, 'Parse::RecDescent::InterpLit' ),
17000
                                                                                              bless( {
17001
                                                                                                       'subrule' => 'date',
17002
                                                                                                       'matchrule' => 0,
17003
                                                                                                       'implicit' => undef,
17004
                                                                                                       'argcode' => undef,
17005
                                                                                                       'lookahead' => 0,
17006
                                                                                                       'line' => 155
17007
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
17008
                                                                                              bless( {
17009
                                                                                                       'subrule' => 'subject',
17010
                                                                                                       'matchrule' => 0,
17011
                                                                                                       'implicit' => undef,
17012
                                                                                                       'argcode' => undef,
17013
                                                                                                       'lookahead' => 0,
17014
                                                                                                       'line' => 155
17015
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
17016
                                                                                              bless( {
17017
                                                                                                       'subrule' => 'from',
17018
                                                                                                       'matchrule' => 0,
17019
                                                                                                       'implicit' => undef,
17020
                                                                                                       'argcode' => undef,
17021
                                                                                                       'lookahead' => 0,
17022
                                                                                                       'line' => 155
17023
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
17024
                                                                                              bless( {
17025
                                                                                                       'subrule' => 'sender',
17026
                                                                                                       'matchrule' => 0,
17027
                                                                                                       'implicit' => undef,
17028
                                                                                                       'argcode' => undef,
17029
                                                                                                       'lookahead' => 0,
17030
                                                                                                       'line' => 155
17031
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
17032
                                                                                              bless( {
17033
                                                                                                       'subrule' => 'replyto',
17034
                                                                                                       'matchrule' => 0,
17035
                                                                                                       'implicit' => undef,
17036
                                                                                                       'argcode' => undef,
17037
                                                                                                       'lookahead' => 0,
17038
                                                                                                       'line' => 155
17039
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
17040
                                                                                              bless( {
17041
                                                                                                       'subrule' => 'to',
17042
                                                                                                       'matchrule' => 0,
17043
                                                                                                       'implicit' => undef,
17044
                                                                                                       'argcode' => undef,
17045
                                                                                                       'lookahead' => 0,
17046
                                                                                                       'line' => 155
17047
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
17048
                                                                                              bless( {
17049
                                                                                                       'subrule' => 'cc',
17050
                                                                                                       'matchrule' => 0,
17051
                                                                                                       'implicit' => undef,
17052
                                                                                                       'argcode' => undef,
17053
                                                                                                       'lookahead' => 0,
17054
                                                                                                       'line' => 155
17055
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
17056
                                                                                              bless( {
17057
                                                                                                       'subrule' => 'bcc',
17058
                                                                                                       'matchrule' => 0,
17059
                                                                                                       'implicit' => undef,
17060
                                                                                                       'argcode' => undef,
17061
                                                                                                       'lookahead' => 0,
17062
                                                                                                       'line' => 155
17063
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
17064
                                                                                              bless( {
17065
                                                                                                       'subrule' => 'inreplyto',
17066
                                                                                                       'matchrule' => 0,
17067
                                                                                                       'implicit' => undef,
17068
                                                                                                       'argcode' => undef,
17069
                                                                                                       'lookahead' => 0,
17070
                                                                                                       'line' => 155
17071
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
17072
                                                                                              bless( {
17073
                                                                                                       'subrule' => 'messageid',
17074
                                                                                                       'matchrule' => 0,
17075
                                                                                                       'implicit' => undef,
17076
                                                                                                       'argcode' => undef,
17077
                                                                                                       'lookahead' => 0,
17078
                                                                                                       'line' => 155
17079
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
17080
                                                                                              bless( {
17081
                                                                                                       'pattern' => ')',
17082
                                                                                                       'hashname' => '__STRING2__',
17083
                                                                                                       'description' => '\')\'',
17084
                                                                                                       'lookahead' => 0,
17085
                                                                                                       'line' => 155
17086
                                                                                                     }, 'Parse::RecDescent::InterpLit' ),
17087
                                                                                              bless( {
17088
                                                                                                       'hashname' => '__ACTION1__',
17089
                                                                                                       'lookahead' => 0,
17090
                                                                                                       'line' => 156,
17091
                                                                                                       'code' => '{ $return = {}; 
17092
	  foreach my $what (qw/date subject from sender replyto to cc bcc inreplyto messageid/) {
17093
		$return->{$what} = $item{$what};
17094
	  }
17095
	  bless $return, "Mail::IMAPClient::BodyStructure::Envelope";
17096
	  $return||defined($return);
17097
	}'
17098
                                                                                                     }, 'Parse::RecDescent::Action' )
17099
                                                                                            ],
17100
                                                                                 'line' => undef
17101
                                                                               }, 'Parse::RecDescent::Production' )
17102
                                                                      ],
17103
                                                           'name' => 'envelopestruct',
17104
                                                           'vars' => '',
17105
                                                           'line' => 155
17106
                                                         }, 'Parse::RecDescent::Rule' ),
17107
                              'replyto' => bless( {
17108
                                                    'impcount' => 0,
17109
                                                    'calls' => [
17110
                                                                 'NIL',
17111
                                                                 'addressstruct'
17112
                                                               ],
17113
                                                    'changed' => 0,
17114
                                                    'opcount' => 0,
17115
                                                    'prods' => [
17116
                                                                 bless( {
17117
                                                                          'number' => '0',
17118
                                                                          'strcount' => 0,
17119
                                                                          'dircount' => 0,
17120
                                                                          'uncommit' => undef,
17121
                                                                          'error' => undef,
17122
                                                                          'patcount' => 0,
17123
                                                                          'actcount' => 0,
17124
                                                                          'items' => [
17125
                                                                                       bless( {
17126
                                                                                                'subrule' => 'NIL',
17127
                                                                                                'matchrule' => 0,
17128
                                                                                                'implicit' => undef,
17129
                                                                                                'argcode' => undef,
17130
                                                                                                'lookahead' => 0,
17131
                                                                                                'line' => 146
17132
                                                                                              }, 'Parse::RecDescent::Subrule' )
17133
                                                                                     ],
17134
                                                                          'line' => undef
17135
                                                                        }, 'Parse::RecDescent::Production' ),
17136
                                                                 bless( {
17137
                                                                          'number' => '1',
17138
                                                                          'strcount' => 2,
17139
                                                                          'dircount' => 0,
17140
                                                                          'uncommit' => undef,
17141
                                                                          'error' => undef,
17142
                                                                          'patcount' => 0,
17143
                                                                          'actcount' => 1,
17144
                                                                          'items' => [
17145
                                                                                       bless( {
17146
                                                                                                'pattern' => '(',
17147
                                                                                                'hashname' => '__STRING1__',
17148
                                                                                                'description' => '\'(\'',
17149
                                                                                                'lookahead' => 0,
17150
                                                                                                'line' => 146
17151
                                                                                              }, 'Parse::RecDescent::InterpLit' ),
17152
                                                                                       bless( {
17153
                                                                                                'subrule' => 'addressstruct',
17154
                                                                                                'expected' => undef,
17155
                                                                                                'min' => 1,
17156
                                                                                                'argcode' => undef,
17157
                                                                                                'max' => 100000000,
17158
                                                                                                'matchrule' => 0,
17159
                                                                                                'repspec' => 's',
17160
                                                                                                'lookahead' => 0,
17161
                                                                                                'line' => 146
17162
                                                                                              }, 'Parse::RecDescent::Repetition' ),
17163
                                                                                       bless( {
17164
                                                                                                'pattern' => ')',
17165
                                                                                                'hashname' => '__STRING2__',
17166
                                                                                                'description' => '\')\'',
17167
                                                                                                'lookahead' => 0,
17168
                                                                                                'line' => 146
17169
                                                                                              }, 'Parse::RecDescent::InterpLit' ),
17170
                                                                                       bless( {
17171
                                                                                                'hashname' => '__ACTION1__',
17172
                                                                                                'lookahead' => 0,
17173
                                                                                                'line' => 147,
17174
                                                                                                'code' => '{ $return = $item{NIL} || $item{\'addressstruct(s)\'} }'
17175
                                                                                              }, 'Parse::RecDescent::Action' )
17176
                                                                                     ],
17177
                                                                          'line' => 146
17178
                                                                        }, 'Parse::RecDescent::Production' )
17179
                                                               ],
17180
                                                    'name' => 'replyto',
17181
                                                    'vars' => '',
17182
                                                    'line' => 146
17183
                                                  }, 'Parse::RecDescent::Rule' ),
17184
                              'mailboxname' => bless( {
17185
                                                        'impcount' => 0,
17186
                                                        'calls' => [
17187
                                                                     'NIL',
17188
                                                                     'STRING'
17189
                                                                   ],
17190
                                                        'changed' => 0,
17191
                                                        'opcount' => 0,
17192
                                                        'prods' => [
17193
                                                                     bless( {
17194
                                                                              'number' => '0',
17195
                                                                              'strcount' => 0,
17196
                                                                              'dircount' => 0,
17197
                                                                              'uncommit' => undef,
17198
                                                                              'error' => undef,
17199
                                                                              'patcount' => 0,
17200
                                                                              'actcount' => 0,
17201
                                                                              'items' => [
17202
                                                                                           bless( {
17203
                                                                                                    'subrule' => 'NIL',
17204
                                                                                                    'matchrule' => 0,
17205
                                                                                                    'implicit' => undef,
17206
                                                                                                    'argcode' => undef,
17207
                                                                                                    'lookahead' => 0,
17208
                                                                                                    'line' => 110
17209
                                                                                                  }, 'Parse::RecDescent::Subrule' )
17210
                                                                                         ],
17211
                                                                              'line' => undef
17212
                                                                            }, 'Parse::RecDescent::Production' ),
17213
                                                                     bless( {
17214
                                                                              'number' => '1',
17215
                                                                              'strcount' => 0,
17216
                                                                              'dircount' => 0,
17217
                                                                              'uncommit' => undef,
17218
                                                                              'error' => undef,
17219
                                                                              'patcount' => 0,
17220
                                                                              'actcount' => 1,
17221
                                                                              'items' => [
17222
                                                                                           bless( {
17223
                                                                                                    'subrule' => 'STRING',
17224
                                                                                                    'matchrule' => 0,
17225
                                                                                                    'implicit' => undef,
17226
                                                                                                    'argcode' => undef,
17227
                                                                                                    'lookahead' => 0,
17228
                                                                                                    'line' => 110
17229
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
17230
                                                                                           bless( {
17231
                                                                                                    'hashname' => '__ACTION1__',
17232
                                                                                                    'lookahead' => 0,
17233
                                                                                                    'line' => 111,
17234
                                                                                                    'code' => '{ $return = $item{NIL} || $item{STRING} ;$return||defined($return);}'
17235
                                                                                                  }, 'Parse::RecDescent::Action' )
17236
                                                                                         ],
17237
                                                                              'line' => 110
17238
                                                                            }, 'Parse::RecDescent::Production' )
17239
                                                                   ],
17240
                                                        'name' => 'mailboxname',
17241
                                                        'vars' => '',
17242
                                                        'line' => 110
17243
                                                      }, 'Parse::RecDescent::Rule' )
17244
                            }
17245
               }, 'Parse::RecDescent' );
17246
}