1 using
2 using System.Collections;
3 using System.Lex;
4 using System.Parsing;
5 using System.Net.Http;
6
7
8
9 unnamed_ns_58F60AAB0B20A6A32316D3E4A86188F987A51778;using System;using System.Collections;using System.Lex;using System.Parsing;using System.Net.Http;
10 {
11 public const int[3] s28 =
;
12 public const int[3] s27 =
;
13 public const int[3] s26 =
;
14 public const int[3] s25 =
;
15 public const int[3] s24 =
;
16 public const int[3] s23 =
;
17 public const int[3] s22 =
;
18 public const int[3] s21 =
;
19 public const int[3] s20 =
;
20 public const int[3] s19 =
;
21 public const int[3] s18 =
;
22 public const int[3] s17 =
;
23 public const int[6] s16 =
;
24 public const int[8] s15 =
;
25 public const int[6] s14 =
;
26 public const int[8] s13 =
;
27 public const int[9] s12 =
;
28 public const int[7] s11 =
;
29 public const int[6] s10 =
;
30 public const int[3] s9 =
;
31 public const int[3] s8 =
;
32 public const int[3] s7 =
;
33 public const int[3] s6 =
;
34 public const int[3] s5 =
;
35 public const int[3] s4 =
;
36 public const int[3] s3 =
;
37 public const int[3] s2 =
;
38 public const int[1] s1 =
;
39 public const int[3] s0 =
;
40 public const Range[1] s29 =
;
41 }
42 public static class HttpDateParser
43 {
44 public static DateTime Parse(TrivialLexer& lexer)
45 {
46 UniquePtr<Value<DateTime>> value;
47 #if (DEBUG)
48 if (lexer.Log() != null)
49 {
50 lexer.Log()->WriteBeginRule(u"parse");
51 lexer.Log()->IncIndent();
52 }
53 #endif
54 ++lexer;
55 System.Lex.Span span = lexer.GetSpan();
56 Match match = HttpDate(lexer);
57 value.Reset(cast<Value<DateTime>*>(match.value));
58 #if (DEBUG)
59 if (lexer.Log() != null)
60 {
61 lexer.Log()->DecIndent();
62 lexer.Log()->WriteEndRule(u"parse");
63 }
64 #endif
65 if (match.hit)
66 {
67 if (*lexer == System.Lex.END_TOKEN)
68 {
69 return value->value;
70 }
71 else
72 {
73 lexer.ThrowExpectationFailure(lexer.GetSpan(), GetEndTokenInfo());
74 }
75 }
76 else
77 {
78 lexer.ThrowExpectationFailure(span, u"HttpDate");
79 }
80 return value->value;
81 }
82 public static Match HttpDate(TrivialLexer& lexer)
83 {
84 #if (DEBUG)
85 Span debugSpan;
86 bool writeToLog = lexer.Log() != null;
87 if (writeToLog)
88 {
89 debugSpan = lexer.GetSpan();
90 System.Lex.WriteBeginRuleToLog(lexer, u"HttpDate");
91 }
92 #endif
93 UniquePtr<Value<DateTime>> d1;
94 UniquePtr<Value<DateTime>> d2;
95 UniquePtr<Value<DateTime>> d3;
96 Match match(false);
97 Match* parentMatch0 = &match;
98 {
99 long save = lexer.GetPos();
100 Match match(false);
101 Match* parentMatch1 = &match;
102 {
103 long save = lexer.GetPos();
104 Match match(false);
105 Match* parentMatch2 = &match;
106 {
107 long pos = lexer.GetPos();
108 Match match = HttpDateParser.RFC1123Date(lexer);
109 d1.Reset(cast<Value<DateTime>*>(match.value));
110 if (match.hit)
111 {
112 {
113 #if (DEBUG)
114 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"HttpDate");
115 #endif
116 return Match(true, new Value<DateTime>(d1->value));
117 }
118 }
119 *parentMatch2 = match;
120 }
121 *parentMatch1 = match;
122 if (!match.hit)
123 {
124 Match match(false);
125 Match* parentMatch3 = &match;
126 lexer.SetPos(save);
127 {
128 Match match(false);
129 Match* parentMatch4 = &match;
130 {
131 long pos = lexer.GetPos();
132 Match match = HttpDateParser.RFC850Date(lexer);
133 d2.Reset(cast<Value<DateTime>*>(match.value));
134 if (match.hit)
135 {
136 {
137 #if (DEBUG)
138 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"HttpDate");
139 #endif
140 return Match(true, new Value<DateTime>(d2->value));
141 }
142 }
143 *parentMatch4 = match;
144 }
145 *parentMatch3 = match;
146 }
147 *parentMatch1 = match;
148 }
149 }
150 *parentMatch0 = match;
151 if (!match.hit)
152 {
153 Match match(false);
154 Match* parentMatch5 = &match;
155 lexer.SetPos(save);
156 {
157 Match match(false);
158 Match* parentMatch6 = &match;
159 {
160 long pos = lexer.GetPos();
161 Match match = HttpDateParser.AscTimeDate(lexer);
162 d3.Reset(cast<Value<DateTime>*>(match.value));
163 if (match.hit)
164 {
165 {
166 #if (DEBUG)
167 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"HttpDate");
168 #endif
169 return Match(true, new Value<DateTime>(d3->value));
170 }
171 }
172 *parentMatch6 = match;
173 }
174 *parentMatch5 = match;
175 }
176 *parentMatch0 = match;
177 }
178 }
179 #if (DEBUG)
180 if (writeToLog)
181 {
182 if (match.hit)
183 {
184 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"HttpDate");
185 }
186 else
187 {
188 System.Lex.WriteFailureToLog(lexer, u"HttpDate");
189 }
190 }
191 #endif
192 if (!match.hit)
193 {
194 match.value = null;
195 }
196 return match;
197 }
198 public static Match RFC1123Date(TrivialLexer& lexer)
199 {
200 #if (DEBUG)
201 Span debugSpan;
202 bool writeToLog = lexer.Log() != null;
203 if (writeToLog)
204 {
205 debugSpan = lexer.GetSpan();
206 System.Lex.WriteBeginRuleToLog(lexer, u"RFC1123Date");
207 }
208 #endif
209 UniquePtr<Value<uchar>> sp1;
210 UniquePtr<Value<Date>> d1;
211 UniquePtr<Value<uchar>> sp2;
212 UniquePtr<Value<int>> t;
213 UniquePtr<Value<uchar>> sp3;
214 Match match(false);
215 Match* parentMatch0 = &match;
216 {
217 long pos = lexer.GetPos();
218 Match match(false);
219 Match* parentMatch1 = &match;
220 {
221 Match match(false);
222 Match* parentMatch2 = &match;
223 {
224 Match match(false);
225 Match* parentMatch3 = &match;
226 {
227 Match match(false);
228 Match* parentMatch4 = &match;
229 {
230 Match match(false);
231 Match* parentMatch5 = &match;
232 {
233 Match match(false);
234 Match* parentMatch6 = &match;
235 {
236 Match match(false);
237 Match* parentMatch7 = &match;
238 {
239 Match match(false);
240 Match* parentMatch8 = &match;
241 {
242 Match match = HttpDateParser.wkday(lexer);
243 *parentMatch8 = match;
244 }
245 if (match.hit)
246 {
247 Match match(false);
248 Match* parentMatch9 = &match;
249 {
250 Match match(false);
251 if (*lexer == 44)
252 {
253 ++lexer;
254 match.hit = true;
255 }
256 *parentMatch9 = match;
257 }
258 *parentMatch8 = match;
259 }
260 *parentMatch7 = match;
261 }
262 if (match.hit)
263 {
264 Match match(false);
265 Match* parentMatch10 = &match;
266 {
267 Match match = HttpDateParser.SP(lexer);
268 sp1.Reset(cast<Value<uchar>*>(match.value));
269 *parentMatch10 = match;
270 }
271 *parentMatch7 = match;
272 }
273 *parentMatch6 = match;
274 }
275 if (match.hit)
276 {
277 Match match(false);
278 Match* parentMatch11 = &match;
279 {
280 Match match = HttpDateParser.date1(lexer);
281 d1.Reset(cast<Value<Date>*>(match.value));
282 *parentMatch11 = match;
283 }
284 *parentMatch6 = match;
285 }
286 *parentMatch5 = match;
287 }
288 if (match.hit)
289 {
290 Match match(false);
291 Match* parentMatch12 = &match;
292 {
293 Match match = HttpDateParser.SP(lexer);
294 sp2.Reset(cast<Value<uchar>*>(match.value));
295 *parentMatch12 = match;
296 }
297 *parentMatch5 = match;
298 }
299 *parentMatch4 = match;
300 }
301 if (match.hit)
302 {
303 Match match(false);
304 Match* parentMatch13 = &match;
305 {
306 Match match = HttpDateParser.time(lexer);
307 t.Reset(cast<Value<int>*>(match.value));
308 *parentMatch13 = match;
309 }
310 *parentMatch4 = match;
311 }
312 *parentMatch3 = match;
313 }
314 if (match.hit)
315 {
316 Match match(false);
317 Match* parentMatch14 = &match;
318 {
319 Match match = HttpDateParser.SP(lexer);
320 sp3.Reset(cast<Value<uchar>*>(match.value));
321 *parentMatch14 = match;
322 }
323 *parentMatch3 = match;
324 }
325 *parentMatch2 = match;
326 }
327 if (match.hit)
328 {
329 Match match(false);
330 Match* parentMatch15 = &match;
331 {
332 Match match(true);
333 for (int i : s0)
334 {
335 if (*lexer == i)
336 {
337 ++lexer;
338 }
339 else
340 {
341 match.hit = false;
342 break;
343 }
344 }
345 *parentMatch15 = match;
346 }
347 *parentMatch2 = match;
348 }
349 *parentMatch1 = match;
350 }
351 if (match.hit)
352 {
353 {
354 #if (DEBUG)
355 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"RFC1123Date");
356 #endif
357 return Match(true, new Value<DateTime>(DateTime(d1->value, t->value)));
358 }
359 }
360 *parentMatch0 = match;
361 }
362 #if (DEBUG)
363 if (writeToLog)
364 {
365 if (match.hit)
366 {
367 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"RFC1123Date");
368 }
369 else
370 {
371 System.Lex.WriteFailureToLog(lexer, u"RFC1123Date");
372 }
373 }
374 #endif
375 if (!match.hit)
376 {
377 match.value = null;
378 }
379 return match;
380 }
381 public static Match RFC850Date(TrivialLexer& lexer)
382 {
383 #if (DEBUG)
384 Span debugSpan;
385 bool writeToLog = lexer.Log() != null;
386 if (writeToLog)
387 {
388 debugSpan = lexer.GetSpan();
389 System.Lex.WriteBeginRuleToLog(lexer, u"RFC850Date");
390 }
391 #endif
392 UniquePtr<Value<uchar>> sp1;
393 UniquePtr<Value<Date>> d2;
394 UniquePtr<Value<uchar>> sp2;
395 UniquePtr<Value<int>> t;
396 UniquePtr<Value<uchar>> sp3;
397 Match match(false);
398 Match* parentMatch0 = &match;
399 {
400 long pos = lexer.GetPos();
401 Match match(false);
402 Match* parentMatch1 = &match;
403 {
404 Match match(false);
405 Match* parentMatch2 = &match;
406 {
407 Match match(false);
408 Match* parentMatch3 = &match;
409 {
410 Match match(false);
411 Match* parentMatch4 = &match;
412 {
413 Match match(false);
414 Match* parentMatch5 = &match;
415 {
416 Match match(false);
417 Match* parentMatch6 = &match;
418 {
419 Match match(false);
420 Match* parentMatch7 = &match;
421 {
422 Match match(false);
423 Match* parentMatch8 = &match;
424 {
425 Match match = HttpDateParser.weekday(lexer);
426 *parentMatch8 = match;
427 }
428 if (match.hit)
429 {
430 Match match(false);
431 Match* parentMatch9 = &match;
432 {
433 Match match(true);
434 for (int i : s1)
435 {
436 if (*lexer == i)
437 {
438 ++lexer;
439 }
440 else
441 {
442 match.hit = false;
443 break;
444 }
445 }
446 *parentMatch9 = match;
447 }
448 *parentMatch8 = match;
449 }
450 *parentMatch7 = match;
451 }
452 if (match.hit)
453 {
454 Match match(false);
455 Match* parentMatch10 = &match;
456 {
457 Match match = HttpDateParser.SP(lexer);
458 sp1.Reset(cast<Value<uchar>*>(match.value));
459 *parentMatch10 = match;
460 }
461 *parentMatch7 = match;
462 }
463 *parentMatch6 = match;
464 }
465 if (match.hit)
466 {
467 Match match(false);
468 Match* parentMatch11 = &match;
469 {
470 Match match = HttpDateParser.date2(lexer);
471 d2.Reset(cast<Value<Date>*>(match.value));
472 *parentMatch11 = match;
473 }
474 *parentMatch6 = match;
475 }
476 *parentMatch5 = match;
477 }
478 if (match.hit)
479 {
480 Match match(false);
481 Match* parentMatch12 = &match;
482 {
483 Match match = HttpDateParser.SP(lexer);
484 sp2.Reset(cast<Value<uchar>*>(match.value));
485 *parentMatch12 = match;
486 }
487 *parentMatch5 = match;
488 }
489 *parentMatch4 = match;
490 }
491 if (match.hit)
492 {
493 Match match(false);
494 Match* parentMatch13 = &match;
495 {
496 Match match = HttpDateParser.time(lexer);
497 t.Reset(cast<Value<int>*>(match.value));
498 *parentMatch13 = match;
499 }
500 *parentMatch4 = match;
501 }
502 *parentMatch3 = match;
503 }
504 if (match.hit)
505 {
506 Match match(false);
507 Match* parentMatch14 = &match;
508 {
509 Match match = HttpDateParser.SP(lexer);
510 sp3.Reset(cast<Value<uchar>*>(match.value));
511 *parentMatch14 = match;
512 }
513 *parentMatch3 = match;
514 }
515 *parentMatch2 = match;
516 }
517 if (match.hit)
518 {
519 Match match(false);
520 Match* parentMatch15 = &match;
521 {
522 Match match(true);
523 for (int i : s2)
524 {
525 if (*lexer == i)
526 {
527 ++lexer;
528 }
529 else
530 {
531 match.hit = false;
532 break;
533 }
534 }
535 *parentMatch15 = match;
536 }
537 *parentMatch2 = match;
538 }
539 *parentMatch1 = match;
540 }
541 if (match.hit)
542 {
543 {
544 #if (DEBUG)
545 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"RFC850Date");
546 #endif
547 return Match(true, new Value<DateTime>(DateTime(d2->value, t->value)));
548 }
549 }
550 *parentMatch0 = match;
551 }
552 #if (DEBUG)
553 if (writeToLog)
554 {
555 if (match.hit)
556 {
557 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"RFC850Date");
558 }
559 else
560 {
561 System.Lex.WriteFailureToLog(lexer, u"RFC850Date");
562 }
563 }
564 #endif
565 if (!match.hit)
566 {
567 match.value = null;
568 }
569 return match;
570 }
571 public static Match AscTimeDate(TrivialLexer& lexer)
572 {
573 #if (DEBUG)
574 Span debugSpan;
575 bool writeToLog = lexer.Log() != null;
576 if (writeToLog)
577 {
578 debugSpan = lexer.GetSpan();
579 System.Lex.WriteBeginRuleToLog(lexer, u"AscTimeDate");
580 }
581 #endif
582 Date monthday;
583 UniquePtr<Value<uchar>> sp1;
584 UniquePtr<Value<Date>> md;
585 UniquePtr<Value<uchar>> sp2;
586 UniquePtr<Value<int>> t;
587 UniquePtr<Value<uchar>> sp3;
588 UniquePtr<Value<short>> y;
589 Match match(false);
590 Match* parentMatch0 = &match;
591 {
592 long pos = lexer.GetPos();
593 Match match(false);
594 Match* parentMatch1 = &match;
595 {
596 Match match(false);
597 Match* parentMatch2 = &match;
598 {
599 Match match(false);
600 Match* parentMatch3 = &match;
601 {
602 Match match(false);
603 Match* parentMatch4 = &match;
604 {
605 Match match(false);
606 Match* parentMatch5 = &match;
607 {
608 Match match(false);
609 Match* parentMatch6 = &match;
610 {
611 Match match(false);
612 Match* parentMatch7 = &match;
613 {
614 Match match = HttpDateParser.wkday(lexer);
615 *parentMatch7 = match;
616 }
617 if (match.hit)
618 {
619 Match match(false);
620 Match* parentMatch8 = &match;
621 {
622 Match match = HttpDateParser.SP(lexer);
623 sp1.Reset(cast<Value<uchar>*>(match.value));
624 *parentMatch8 = match;
625 }
626 *parentMatch7 = match;
627 }
628 *parentMatch6 = match;
629 }
630 if (match.hit)
631 {
632 Match match(false);
633 Match* parentMatch9 = &match;
634 {
635 Match match(false);
636 Match* parentMatch10 = &match;
637 {
638 long pos = lexer.GetPos();
639 Match match = HttpDateParser.date3(lexer);
640 md.Reset(cast<Value<Date>*>(match.value));
641 if (match.hit)
642 {
643 monthday = md->value;
644 }
645 *parentMatch10 = match;
646 }
647 *parentMatch9 = match;
648 }
649 *parentMatch6 = match;
650 }
651 *parentMatch5 = match;
652 }
653 if (match.hit)
654 {
655 Match match(false);
656 Match* parentMatch11 = &match;
657 {
658 Match match = HttpDateParser.SP(lexer);
659 sp2.Reset(cast<Value<uchar>*>(match.value));
660 *parentMatch11 = match;
661 }
662 *parentMatch5 = match;
663 }
664 *parentMatch4 = match;
665 }
666 if (match.hit)
667 {
668 Match match(false);
669 Match* parentMatch12 = &match;
670 {
671 Match match = HttpDateParser.time(lexer);
672 t.Reset(cast<Value<int>*>(match.value));
673 *parentMatch12 = match;
674 }
675 *parentMatch4 = match;
676 }
677 *parentMatch3 = match;
678 }
679 if (match.hit)
680 {
681 Match match(false);
682 Match* parentMatch13 = &match;
683 {
684 Match match = HttpDateParser.SP(lexer);
685 sp3.Reset(cast<Value<uchar>*>(match.value));
686 *parentMatch13 = match;
687 }
688 *parentMatch3 = match;
689 }
690 *parentMatch2 = match;
691 }
692 if (match.hit)
693 {
694 Match match(false);
695 Match* parentMatch14 = &match;
696 {
697 Match match = HttpDateParser.Year(lexer);
698 y.Reset(cast<Value<short>*>(match.value));
699 *parentMatch14 = match;
700 }
701 *parentMatch2 = match;
702 }
703 *parentMatch1 = match;
704 }
705 if (match.hit)
706 {
707 {
708 #if (DEBUG)
709 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AscTimeDate");
710 #endif
711 return Match(true, new Value<DateTime>(DateTime(Date(y->value, monthday.GetMonth(), monthday.Day()), t->value)));
712 }
713 }
714 *parentMatch0 = match;
715 }
716 #if (DEBUG)
717 if (writeToLog)
718 {
719 if (match.hit)
720 {
721 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AscTimeDate");
722 }
723 else
724 {
725 System.Lex.WriteFailureToLog(lexer, u"AscTimeDate");
726 }
727 }
728 #endif
729 if (!match.hit)
730 {
731 match.value = null;
732 }
733 return match;
734 }
735 public static Match date1(TrivialLexer& lexer)
736 {
737 #if (DEBUG)
738 Span debugSpan;
739 bool writeToLog = lexer.Log() != null;
740 if (writeToLog)
741 {
742 debugSpan = lexer.GetSpan();
743 System.Lex.WriteBeginRuleToLog(lexer, u"date1");
744 }
745 #endif
746 UniquePtr<Value<sbyte>> day;
747 UniquePtr<Value<uchar>> sp1;
748 UniquePtr<Value<Month>> m;
749 UniquePtr<Value<uchar>> sp2;
750 UniquePtr<Value<short>> y;
751 Match match(false);
752 Match* parentMatch0 = &match;
753 {
754 long pos = lexer.GetPos();
755 Match match(false);
756 Match* parentMatch1 = &match;
757 {
758 Match match(false);
759 Match* parentMatch2 = &match;
760 {
761 Match match(false);
762 Match* parentMatch3 = &match;
763 {
764 Match match(false);
765 Match* parentMatch4 = &match;
766 {
767 Match match(false);
768 Match* parentMatch5 = &match;
769 {
770 Match match = HttpDateParser.Day(lexer);
771 day.Reset(cast<Value<sbyte>*>(match.value));
772 *parentMatch5 = match;
773 }
774 if (match.hit)
775 {
776 Match match(false);
777 Match* parentMatch6 = &match;
778 {
779 Match match = HttpDateParser.SP(lexer);
780 sp1.Reset(cast<Value<uchar>*>(match.value));
781 *parentMatch6 = match;
782 }
783 *parentMatch5 = match;
784 }
785 *parentMatch4 = match;
786 }
787 if (match.hit)
788 {
789 Match match(false);
790 Match* parentMatch7 = &match;
791 {
792 Match match = HttpDateParser.month(lexer);
793 m.Reset(cast<Value<Month>*>(match.value));
794 *parentMatch7 = match;
795 }
796 *parentMatch4 = match;
797 }
798 *parentMatch3 = match;
799 }
800 if (match.hit)
801 {
802 Match match(false);
803 Match* parentMatch8 = &match;
804 {
805 Match match = HttpDateParser.SP(lexer);
806 sp2.Reset(cast<Value<uchar>*>(match.value));
807 *parentMatch8 = match;
808 }
809 *parentMatch3 = match;
810 }
811 *parentMatch2 = match;
812 }
813 if (match.hit)
814 {
815 Match match(false);
816 Match* parentMatch9 = &match;
817 {
818 Match match = HttpDateParser.Year(lexer);
819 y.Reset(cast<Value<short>*>(match.value));
820 *parentMatch9 = match;
821 }
822 *parentMatch2 = match;
823 }
824 *parentMatch1 = match;
825 }
826 if (match.hit)
827 {
828 {
829 #if (DEBUG)
830 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"date1");
831 #endif
832 return Match(true, new Value<Date>(Date(y->value, m->value, day->value)));
833 }
834 }
835 *parentMatch0 = match;
836 }
837 #if (DEBUG)
838 if (writeToLog)
839 {
840 if (match.hit)
841 {
842 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"date1");
843 }
844 else
845 {
846 System.Lex.WriteFailureToLog(lexer, u"date1");
847 }
848 }
849 #endif
850 if (!match.hit)
851 {
852 match.value = null;
853 }
854 return match;
855 }
856 public static Match date2(TrivialLexer& lexer)
857 {
858 #if (DEBUG)
859 Span debugSpan;
860 bool writeToLog = lexer.Log() != null;
861 if (writeToLog)
862 {
863 debugSpan = lexer.GetSpan();
864 System.Lex.WriteBeginRuleToLog(lexer, u"date2");
865 }
866 #endif
867 UniquePtr<Value<sbyte>> day;
868 UniquePtr<Value<Month>> m;
869 UniquePtr<Value<short>> y;
870 Match match(false);
871 Match* parentMatch0 = &match;
872 {
873 long pos = lexer.GetPos();
874 Match match(false);
875 Match* parentMatch1 = &match;
876 {
877 Match match(false);
878 Match* parentMatch2 = &match;
879 {
880 Match match(false);
881 Match* parentMatch3 = &match;
882 {
883 Match match(false);
884 Match* parentMatch4 = &match;
885 {
886 Match match(false);
887 Match* parentMatch5 = &match;
888 {
889 Match match = HttpDateParser.Day(lexer);
890 day.Reset(cast<Value<sbyte>*>(match.value));
891 *parentMatch5 = match;
892 }
893 if (match.hit)
894 {
895 Match match(false);
896 Match* parentMatch6 = &match;
897 {
898 Match match(false);
899 if (*lexer == 45)
900 {
901 ++lexer;
902 match.hit = true;
903 }
904 *parentMatch6 = match;
905 }
906 *parentMatch5 = match;
907 }
908 *parentMatch4 = match;
909 }
910 if (match.hit)
911 {
912 Match match(false);
913 Match* parentMatch7 = &match;
914 {
915 Match match = HttpDateParser.month(lexer);
916 m.Reset(cast<Value<Month>*>(match.value));
917 *parentMatch7 = match;
918 }
919 *parentMatch4 = match;
920 }
921 *parentMatch3 = match;
922 }
923 if (match.hit)
924 {
925 Match match(false);
926 Match* parentMatch8 = &match;
927 {
928 Match match(false);
929 if (*lexer == 45)
930 {
931 ++lexer;
932 match.hit = true;
933 }
934 *parentMatch8 = match;
935 }
936 *parentMatch3 = match;
937 }
938 *parentMatch2 = match;
939 }
940 if (match.hit)
941 {
942 Match match(false);
943 Match* parentMatch9 = &match;
944 {
945 Match match = HttpDateParser.Year2(lexer);
946 y.Reset(cast<Value<short>*>(match.value));
947 *parentMatch9 = match;
948 }
949 *parentMatch2 = match;
950 }
951 *parentMatch1 = match;
952 }
953 if (match.hit)
954 {
955 {
956 #if (DEBUG)
957 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"date2");
958 #endif
959 return Match(true, new Value<Date>(Date(y->value, m->value, day->value)));
960 }
961 }
962 *parentMatch0 = match;
963 }
964 #if (DEBUG)
965 if (writeToLog)
966 {
967 if (match.hit)
968 {
969 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"date2");
970 }
971 else
972 {
973 System.Lex.WriteFailureToLog(lexer, u"date2");
974 }
975 }
976 #endif
977 if (!match.hit)
978 {
979 match.value = null;
980 }
981 return match;
982 }
983 public static Match date3(TrivialLexer& lexer)
984 {
985 #if (DEBUG)
986 Span debugSpan;
987 bool writeToLog = lexer.Log() != null;
988 if (writeToLog)
989 {
990 debugSpan = lexer.GetSpan();
991 System.Lex.WriteBeginRuleToLog(lexer, u"date3");
992 }
993 #endif
994 sbyte d;
995 UniquePtr<Value<Month>> m;
996 UniquePtr<Value<uchar>> sp;
997 UniquePtr<Value<sbyte>> day;
998 UniquePtr<Value<sbyte>> day1;
999 Match match(false);
1000 Match* parentMatch0 = &match;
1001 {
1002 long pos = lexer.GetPos();
1003 Match match(false);
1004 Match* parentMatch1 = &match;
1005 {
1006 Match match(false);
1007 Match* parentMatch2 = &match;
1008 {
1009 Match match(false);
1010 Match* parentMatch3 = &match;
1011 {
1012 Match match = HttpDateParser.month(lexer);
1013 m.Reset(cast<Value<Month>*>(match.value));
1014 *parentMatch3 = match;
1015 }
1016 if (match.hit)
1017 {
1018 Match match(false);
1019 Match* parentMatch4 = &match;
1020 {
1021 Match match = HttpDateParser.SP(lexer);
1022 sp.Reset(cast<Value<uchar>*>(match.value));
1023 *parentMatch4 = match;
1024 }
1025 *parentMatch3 = match;
1026 }
1027 *parentMatch2 = match;
1028 }
1029 if (match.hit)
1030 {
1031 Match match(false);
1032 Match* parentMatch5 = &match;
1033 {
1034 Match match(false);
1035 Match* parentMatch6 = &match;
1036 {
1037 Match match(false);
1038 Match* parentMatch7 = &match;
1039 {
1040 long save = lexer.GetPos();
1041 Match match(false);
1042 Match* parentMatch8 = &match;
1043 {
1044 long pos = lexer.GetPos();
1045 Match match = HttpDateParser.Day(lexer);
1046 day.Reset(cast<Value<sbyte>*>(match.value));
1047 if (match.hit)
1048 {
1049 d = day->value;
1050 }
1051 *parentMatch8 = match;
1052 }
1053 *parentMatch7 = match;
1054 if (!match.hit)
1055 {
1056 Match match(false);
1057 Match* parentMatch9 = &match;
1058 lexer.SetPos(save);
1059 {
1060 Match match(false);
1061 Match* parentMatch10 = &match;
1062 {
1063 long pos = lexer.GetPos();
1064 Match match = HttpDateParser.Day1(lexer);
1065 day1.Reset(cast<Value<sbyte>*>(match.value));
1066 if (match.hit)
1067 {
1068 d = day1->value;
1069 }
1070 *parentMatch10 = match;
1071 }
1072 *parentMatch9 = match;
1073 }
1074 *parentMatch7 = match;
1075 }
1076 }
1077 *parentMatch6 = match;
1078 }
1079 *parentMatch5 = match;
1080 }
1081 *parentMatch2 = match;
1082 }
1083 *parentMatch1 = match;
1084 }
1085 if (match.hit)
1086 {
1087 {
1088 #if (DEBUG)
1089 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"date3");
1090 #endif
1091 return Match(true, new Value<Date>(Date(0, m->value, d)));
1092 }
1093 }
1094 *parentMatch0 = match;
1095 }
1096 #if (DEBUG)
1097 if (writeToLog)
1098 {
1099 if (match.hit)
1100 {
1101 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"date3");
1102 }
1103 else
1104 {
1105 System.Lex.WriteFailureToLog(lexer, u"date3");
1106 }
1107 }
1108 #endif
1109 if (!match.hit)
1110 {
1111 match.value = null;
1112 }
1113 return match;
1114 }
1115 public static Match Year(TrivialLexer& lexer)
1116 {
1117 #if (DEBUG)
1118 Span debugSpan;
1119 bool writeToLog = lexer.Log() != null;
1120 if (writeToLog)
1121 {
1122 debugSpan = lexer.GetSpan();
1123 System.Lex.WriteBeginRuleToLog(lexer, u"Year");
1124 }
1125 #endif
1126 ustring s;
1127 UniquePtr<Value<uchar>> d1;
1128 UniquePtr<Value<uchar>> d2;
1129 UniquePtr<Value<uchar>> d3;
1130 UniquePtr<Value<uchar>> d4;
1131 Match match(false);
1132 Match* parentMatch0 = &match;
1133 {
1134 long pos = lexer.GetPos();
1135 Match match(false);
1136 Match* parentMatch1 = &match;
1137 {
1138 Match match(false);
1139 Match* parentMatch2 = &match;
1140 {
1141 Match match(false);
1142 Match* parentMatch3 = &match;
1143 {
1144 Match match(false);
1145 Match* parentMatch4 = &match;
1146 {
1147 Match match(false);
1148 Match* parentMatch5 = &match;
1149 {
1150 long pos = lexer.GetPos();
1151 Match match = HttpDateParser.DIGIT(lexer);
1152 d1.Reset(cast<Value<uchar>*>(match.value));
1153 if (match.hit)
1154 {
1155 s.Append(d1->value);
1156 }
1157 *parentMatch5 = match;
1158 }
1159 *parentMatch4 = match;
1160 }
1161 if (match.hit)
1162 {
1163 Match match(false);
1164 Match* parentMatch6 = &match;
1165 {
1166 Match match(false);
1167 Match* parentMatch7 = &match;
1168 {
1169 long pos = lexer.GetPos();
1170 Match match = HttpDateParser.DIGIT(lexer);
1171 d2.Reset(cast<Value<uchar>*>(match.value));
1172 if (match.hit)
1173 {
1174 s.Append(d2->value);
1175 }
1176 *parentMatch7 = match;
1177 }
1178 *parentMatch6 = match;
1179 }
1180 *parentMatch4 = match;
1181 }
1182 *parentMatch3 = match;
1183 }
1184 if (match.hit)
1185 {
1186 Match match(false);
1187 Match* parentMatch8 = &match;
1188 {
1189 Match match(false);
1190 Match* parentMatch9 = &match;
1191 {
1192 long pos = lexer.GetPos();
1193 Match match = HttpDateParser.DIGIT(lexer);
1194 d3.Reset(cast<Value<uchar>*>(match.value));
1195 if (match.hit)
1196 {
1197 s.Append(d3->value);
1198 }
1199 *parentMatch9 = match;
1200 }
1201 *parentMatch8 = match;
1202 }
1203 *parentMatch3 = match;
1204 }
1205 *parentMatch2 = match;
1206 }
1207 if (match.hit)
1208 {
1209 Match match(false);
1210 Match* parentMatch10 = &match;
1211 {
1212 Match match(false);
1213 Match* parentMatch11 = &match;
1214 {
1215 long pos = lexer.GetPos();
1216 Match match = HttpDateParser.DIGIT(lexer);
1217 d4.Reset(cast<Value<uchar>*>(match.value));
1218 if (match.hit)
1219 {
1220 s.Append(d4->value);
1221 }
1222 *parentMatch11 = match;
1223 }
1224 *parentMatch10 = match;
1225 }
1226 *parentMatch2 = match;
1227 }
1228 *parentMatch1 = match;
1229 }
1230 if (match.hit)
1231 {
1232 {
1233 #if (DEBUG)
1234 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Year");
1235 #endif
1236 return Match(true, new Value<short>(ParseShort(ToUtf8(s))));
1237 }
1238 }
1239 *parentMatch0 = match;
1240 }
1241 #if (DEBUG)
1242 if (writeToLog)
1243 {
1244 if (match.hit)
1245 {
1246 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Year");
1247 }
1248 else
1249 {
1250 System.Lex.WriteFailureToLog(lexer, u"Year");
1251 }
1252 }
1253 #endif
1254 if (!match.hit)
1255 {
1256 match.value = null;
1257 }
1258 return match;
1259 }
1260 public static Match Year2(TrivialLexer& lexer)
1261 {
1262 #if (DEBUG)
1263 Span debugSpan;
1264 bool writeToLog = lexer.Log() != null;
1265 if (writeToLog)
1266 {
1267 debugSpan = lexer.GetSpan();
1268 System.Lex.WriteBeginRuleToLog(lexer, u"Year2");
1269 }
1270 #endif
1271 ustring s;
1272 UniquePtr<Value<uchar>> d1;
1273 UniquePtr<Value<uchar>> d2;
1274 Match match(false);
1275 Match* parentMatch0 = &match;
1276 {
1277 long pos = lexer.GetPos();
1278 Match match(false);
1279 Match* parentMatch1 = &match;
1280 {
1281 Match match(false);
1282 Match* parentMatch2 = &match;
1283 {
1284 Match match(false);
1285 Match* parentMatch3 = &match;
1286 {
1287 long pos = lexer.GetPos();
1288 Match match = HttpDateParser.DIGIT(lexer);
1289 d1.Reset(cast<Value<uchar>*>(match.value));
1290 if (match.hit)
1291 {
1292 s.Append(d1->value);
1293 }
1294 *parentMatch3 = match;
1295 }
1296 *parentMatch2 = match;
1297 }
1298 if (match.hit)
1299 {
1300 Match match(false);
1301 Match* parentMatch4 = &match;
1302 {
1303 Match match(false);
1304 Match* parentMatch5 = &match;
1305 {
1306 long pos = lexer.GetPos();
1307 Match match = HttpDateParser.DIGIT(lexer);
1308 d2.Reset(cast<Value<uchar>*>(match.value));
1309 if (match.hit)
1310 {
1311 s.Append(d2->value);
1312 }
1313 *parentMatch5 = match;
1314 }
1315 *parentMatch4 = match;
1316 }
1317 *parentMatch2 = match;
1318 }
1319 *parentMatch1 = match;
1320 }
1321 if (match.hit)
1322 {
1323 {
1324 #if (DEBUG)
1325 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Year2");
1326 #endif
1327 return Match(true, new Value<short>(2000 + ParseShort(ToUtf8(s))));
1328 }
1329 }
1330 *parentMatch0 = match;
1331 }
1332 #if (DEBUG)
1333 if (writeToLog)
1334 {
1335 if (match.hit)
1336 {
1337 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Year2");
1338 }
1339 else
1340 {
1341 System.Lex.WriteFailureToLog(lexer, u"Year2");
1342 }
1343 }
1344 #endif
1345 if (!match.hit)
1346 {
1347 match.value = null;
1348 }
1349 return match;
1350 }
1351 public static Match Day(TrivialLexer& lexer)
1352 {
1353 #if (DEBUG)
1354 Span debugSpan;
1355 bool writeToLog = lexer.Log() != null;
1356 if (writeToLog)
1357 {
1358 debugSpan = lexer.GetSpan();
1359 System.Lex.WriteBeginRuleToLog(lexer, u"Day");
1360 }
1361 #endif
1362 ustring s;
1363 UniquePtr<Value<uchar>> d1;
1364 UniquePtr<Value<uchar>> d2;
1365 Match match(false);
1366 Match* parentMatch0 = &match;
1367 {
1368 long pos = lexer.GetPos();
1369 Match match(false);
1370 Match* parentMatch1 = &match;
1371 {
1372 Match match(false);
1373 Match* parentMatch2 = &match;
1374 {
1375 Match match(false);
1376 Match* parentMatch3 = &match;
1377 {
1378 long pos = lexer.GetPos();
1379 Match match = HttpDateParser.DIGIT(lexer);
1380 d1.Reset(cast<Value<uchar>*>(match.value));
1381 if (match.hit)
1382 {
1383 s.Append(d1->value);
1384 }
1385 *parentMatch3 = match;
1386 }
1387 *parentMatch2 = match;
1388 }
1389 if (match.hit)
1390 {
1391 Match match(false);
1392 Match* parentMatch4 = &match;
1393 {
1394 Match match(false);
1395 Match* parentMatch5 = &match;
1396 {
1397 long pos = lexer.GetPos();
1398 Match match = HttpDateParser.DIGIT(lexer);
1399 d2.Reset(cast<Value<uchar>*>(match.value));
1400 if (match.hit)
1401 {
1402 s.Append(d2->value);
1403 }
1404 *parentMatch5 = match;
1405 }
1406 *parentMatch4 = match;
1407 }
1408 *parentMatch2 = match;
1409 }
1410 *parentMatch1 = match;
1411 }
1412 if (match.hit)
1413 {
1414 {
1415 #if (DEBUG)
1416 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Day");
1417 #endif
1418 return Match(true, new Value<sbyte>(ParseSByte(ToUtf8(s))));
1419 }
1420 }
1421 *parentMatch0 = match;
1422 }
1423 #if (DEBUG)
1424 if (writeToLog)
1425 {
1426 if (match.hit)
1427 {
1428 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Day");
1429 }
1430 else
1431 {
1432 System.Lex.WriteFailureToLog(lexer, u"Day");
1433 }
1434 }
1435 #endif
1436 if (!match.hit)
1437 {
1438 match.value = null;
1439 }
1440 return match;
1441 }
1442 public static Match Day1(TrivialLexer& lexer)
1443 {
1444 #if (DEBUG)
1445 Span debugSpan;
1446 bool writeToLog = lexer.Log() != null;
1447 if (writeToLog)
1448 {
1449 debugSpan = lexer.GetSpan();
1450 System.Lex.WriteBeginRuleToLog(lexer, u"Day1");
1451 }
1452 #endif
1453 ustring s;
1454 UniquePtr<Value<uchar>> sp;
1455 UniquePtr<Value<uchar>> digit;
1456 Match match(false);
1457 Match* parentMatch0 = &match;
1458 {
1459 Match match = HttpDateParser.SP(lexer);
1460 sp.Reset(cast<Value<uchar>*>(match.value));
1461 *parentMatch0 = match;
1462 }
1463 if (match.hit)
1464 {
1465 Match match(false);
1466 Match* parentMatch1 = &match;
1467 {
1468 Match match(false);
1469 Match* parentMatch2 = &match;
1470 {
1471 long pos = lexer.GetPos();
1472 Match match = HttpDateParser.DIGIT(lexer);
1473 digit.Reset(cast<Value<uchar>*>(match.value));
1474 if (match.hit)
1475 {
1476 s.Append(digit->value);
1477 {
1478 #if (DEBUG)
1479 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Day1");
1480 #endif
1481 return Match(true, new Value<sbyte>(ParseSByte(ToUtf8(s))));
1482 }
1483 }
1484 *parentMatch2 = match;
1485 }
1486 *parentMatch1 = match;
1487 }
1488 *parentMatch0 = match;
1489 }
1490 #if (DEBUG)
1491 if (writeToLog)
1492 {
1493 if (match.hit)
1494 {
1495 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Day1");
1496 }
1497 else
1498 {
1499 System.Lex.WriteFailureToLog(lexer, u"Day1");
1500 }
1501 }
1502 #endif
1503 if (!match.hit)
1504 {
1505 match.value = null;
1506 }
1507 return match;
1508 }
1509 public static Match wkday(TrivialLexer& lexer)
1510 {
1511 #if (DEBUG)
1512 Span debugSpan;
1513 bool writeToLog = lexer.Log() != null;
1514 if (writeToLog)
1515 {
1516 debugSpan = lexer.GetSpan();
1517 System.Lex.WriteBeginRuleToLog(lexer, u"wkday");
1518 }
1519 #endif
1520 Match match(false);
1521 Match* parentMatch0 = &match;
1522 {
1523 long save = lexer.GetPos();
1524 Match match(false);
1525 Match* parentMatch1 = &match;
1526 {
1527 long save = lexer.GetPos();
1528 Match match(false);
1529 Match* parentMatch2 = &match;
1530 {
1531 long save = lexer.GetPos();
1532 Match match(false);
1533 Match* parentMatch3 = &match;
1534 {
1535 long save = lexer.GetPos();
1536 Match match(false);
1537 Match* parentMatch4 = &match;
1538 {
1539 long save = lexer.GetPos();
1540 Match match(false);
1541 Match* parentMatch5 = &match;
1542 {
1543 long save = lexer.GetPos();
1544 Match match(true);
1545 for (int i : s3)
1546 {
1547 if (*lexer == i)
1548 {
1549 ++lexer;
1550 }
1551 else
1552 {
1553 match.hit = false;
1554 break;
1555 }
1556 }
1557 *parentMatch5 = match;
1558 if (!match.hit)
1559 {
1560 Match match(false);
1561 Match* parentMatch6 = &match;
1562 lexer.SetPos(save);
1563 {
1564 Match match(true);
1565 for (int i : s4)
1566 {
1567 if (*lexer == i)
1568 {
1569 ++lexer;
1570 }
1571 else
1572 {
1573 match.hit = false;
1574 break;
1575 }
1576 }
1577 *parentMatch6 = match;
1578 }
1579 *parentMatch5 = match;
1580 }
1581 }
1582 *parentMatch4 = match;
1583 if (!match.hit)
1584 {
1585 Match match(false);
1586 Match* parentMatch7 = &match;
1587 lexer.SetPos(save);
1588 {
1589 Match match(true);
1590 for (int i : s5)
1591 {
1592 if (*lexer == i)
1593 {
1594 ++lexer;
1595 }
1596 else
1597 {
1598 match.hit = false;
1599 break;
1600 }
1601 }
1602 *parentMatch7 = match;
1603 }
1604 *parentMatch4 = match;
1605 }
1606 }
1607 *parentMatch3 = match;
1608 if (!match.hit)
1609 {
1610 Match match(false);
1611 Match* parentMatch8 = &match;
1612 lexer.SetPos(save);
1613 {
1614 Match match(true);
1615 for (int i : s6)
1616 {
1617 if (*lexer == i)
1618 {
1619 ++lexer;
1620 }
1621 else
1622 {
1623 match.hit = false;
1624 break;
1625 }
1626 }
1627 *parentMatch8 = match;
1628 }
1629 *parentMatch3 = match;
1630 }
1631 }
1632 *parentMatch2 = match;
1633 if (!match.hit)
1634 {
1635 Match match(false);
1636 Match* parentMatch9 = &match;
1637 lexer.SetPos(save);
1638 {
1639 Match match(true);
1640 for (int i : s7)
1641 {
1642 if (*lexer == i)
1643 {
1644 ++lexer;
1645 }
1646 else
1647 {
1648 match.hit = false;
1649 break;
1650 }
1651 }
1652 *parentMatch9 = match;
1653 }
1654 *parentMatch2 = match;
1655 }
1656 }
1657 *parentMatch1 = match;
1658 if (!match.hit)
1659 {
1660 Match match(false);
1661 Match* parentMatch10 = &match;
1662 lexer.SetPos(save);
1663 {
1664 Match match(true);
1665 for (int i : s8)
1666 {
1667 if (*lexer == i)
1668 {
1669 ++lexer;
1670 }
1671 else
1672 {
1673 match.hit = false;
1674 break;
1675 }
1676 }
1677 *parentMatch10 = match;
1678 }
1679 *parentMatch1 = match;
1680 }
1681 }
1682 *parentMatch0 = match;
1683 if (!match.hit)
1684 {
1685 Match match(false);
1686 Match* parentMatch11 = &match;
1687 lexer.SetPos(save);
1688 {
1689 Match match(true);
1690 for (int i : s9)
1691 {
1692 if (*lexer == i)
1693 {
1694 ++lexer;
1695 }
1696 else
1697 {
1698 match.hit = false;
1699 break;
1700 }
1701 }
1702 *parentMatch11 = match;
1703 }
1704 *parentMatch0 = match;
1705 }
1706 }
1707 #if (DEBUG)
1708 if (writeToLog)
1709 {
1710 if (match.hit)
1711 {
1712 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"wkday");
1713 }
1714 else
1715 {
1716 System.Lex.WriteFailureToLog(lexer, u"wkday");
1717 }
1718 }
1719 #endif
1720 if (!match.hit)
1721 {
1722 match.value = null;
1723 }
1724 return match;
1725 }
1726 public static Match weekday(TrivialLexer& lexer)
1727 {
1728 #if (DEBUG)
1729 Span debugSpan;
1730 bool writeToLog = lexer.Log() != null;
1731 if (writeToLog)
1732 {
1733 debugSpan = lexer.GetSpan();
1734 System.Lex.WriteBeginRuleToLog(lexer, u"weekday");
1735 }
1736 #endif
1737 Match match(false);
1738 Match* parentMatch0 = &match;
1739 {
1740 long save = lexer.GetPos();
1741 Match match(false);
1742 Match* parentMatch1 = &match;
1743 {
1744 long save = lexer.GetPos();
1745 Match match(false);
1746 Match* parentMatch2 = &match;
1747 {
1748 long save = lexer.GetPos();
1749 Match match(false);
1750 Match* parentMatch3 = &match;
1751 {
1752 long save = lexer.GetPos();
1753 Match match(false);
1754 Match* parentMatch4 = &match;
1755 {
1756 long save = lexer.GetPos();
1757 Match match(false);
1758 Match* parentMatch5 = &match;
1759 {
1760 long save = lexer.GetPos();
1761 Match match(true);
1762 for (int i : s10)
1763 {
1764 if (*lexer == i)
1765 {
1766 ++lexer;
1767 }
1768 else
1769 {
1770 match.hit = false;
1771 break;
1772 }
1773 }
1774 *parentMatch5 = match;
1775 if (!match.hit)
1776 {
1777 Match match(false);
1778 Match* parentMatch6 = &match;
1779 lexer.SetPos(save);
1780 {
1781 Match match(true);
1782 for (int i : s11)
1783 {
1784 if (*lexer == i)
1785 {
1786 ++lexer;
1787 }
1788 else
1789 {
1790 match.hit = false;
1791 break;
1792 }
1793 }
1794 *parentMatch6 = match;
1795 }
1796 *parentMatch5 = match;
1797 }
1798 }
1799 *parentMatch4 = match;
1800 if (!match.hit)
1801 {
1802 Match match(false);
1803 Match* parentMatch7 = &match;
1804 lexer.SetPos(save);
1805 {
1806 Match match(true);
1807 for (int i : s12)
1808 {
1809 if (*lexer == i)
1810 {
1811 ++lexer;
1812 }
1813 else
1814 {
1815 match.hit = false;
1816 break;
1817 }
1818 }
1819 *parentMatch7 = match;
1820 }
1821 *parentMatch4 = match;
1822 }
1823 }
1824 *parentMatch3 = match;
1825 if (!match.hit)
1826 {
1827 Match match(false);
1828 Match* parentMatch8 = &match;
1829 lexer.SetPos(save);
1830 {
1831 Match match(true);
1832 for (int i : s13)
1833 {
1834 if (*lexer == i)
1835 {
1836 ++lexer;
1837 }
1838 else
1839 {
1840 match.hit = false;
1841 break;
1842 }
1843 }
1844 *parentMatch8 = match;
1845 }
1846 *parentMatch3 = match;
1847 }
1848 }
1849 *parentMatch2 = match;
1850 if (!match.hit)
1851 {
1852 Match match(false);
1853 Match* parentMatch9 = &match;
1854 lexer.SetPos(save);
1855 {
1856 Match match(true);
1857 for (int i : s14)
1858 {
1859 if (*lexer == i)
1860 {
1861 ++lexer;
1862 }
1863 else
1864 {
1865 match.hit = false;
1866 break;
1867 }
1868 }
1869 *parentMatch9 = match;
1870 }
1871 *parentMatch2 = match;
1872 }
1873 }
1874 *parentMatch1 = match;
1875 if (!match.hit)
1876 {
1877 Match match(false);
1878 Match* parentMatch10 = &match;
1879 lexer.SetPos(save);
1880 {
1881 Match match(true);
1882 for (int i : s15)
1883 {
1884 if (*lexer == i)
1885 {
1886 ++lexer;
1887 }
1888 else
1889 {
1890 match.hit = false;
1891 break;
1892 }
1893 }
1894 *parentMatch10 = match;
1895 }
1896 *parentMatch1 = match;
1897 }
1898 }
1899 *parentMatch0 = match;
1900 if (!match.hit)
1901 {
1902 Match match(false);
1903 Match* parentMatch11 = &match;
1904 lexer.SetPos(save);
1905 {
1906 Match match(true);
1907 for (int i : s16)
1908 {
1909 if (*lexer == i)
1910 {
1911 ++lexer;
1912 }
1913 else
1914 {
1915 match.hit = false;
1916 break;
1917 }
1918 }
1919 *parentMatch11 = match;
1920 }
1921 *parentMatch0 = match;
1922 }
1923 }
1924 #if (DEBUG)
1925 if (writeToLog)
1926 {
1927 if (match.hit)
1928 {
1929 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"weekday");
1930 }
1931 else
1932 {
1933 System.Lex.WriteFailureToLog(lexer, u"weekday");
1934 }
1935 }
1936 #endif
1937 if (!match.hit)
1938 {
1939 match.value = null;
1940 }
1941 return match;
1942 }
1943 public static Match month(TrivialLexer& lexer)
1944 {
1945 #if (DEBUG)
1946 Span debugSpan;
1947 bool writeToLog = lexer.Log() != null;
1948 if (writeToLog)
1949 {
1950 debugSpan = lexer.GetSpan();
1951 System.Lex.WriteBeginRuleToLog(lexer, u"month");
1952 }
1953 #endif
1954 Match match(false);
1955 Match* parentMatch0 = &match;
1956 {
1957 long save = lexer.GetPos();
1958 Match match(false);
1959 Match* parentMatch1 = &match;
1960 {
1961 long save = lexer.GetPos();
1962 Match match(false);
1963 Match* parentMatch2 = &match;
1964 {
1965 long save = lexer.GetPos();
1966 Match match(false);
1967 Match* parentMatch3 = &match;
1968 {
1969 long save = lexer.GetPos();
1970 Match match(false);
1971 Match* parentMatch4 = &match;
1972 {
1973 long save = lexer.GetPos();
1974 Match match(false);
1975 Match* parentMatch5 = &match;
1976 {
1977 long save = lexer.GetPos();
1978 Match match(false);
1979 Match* parentMatch6 = &match;
1980 {
1981 long save = lexer.GetPos();
1982 Match match(false);
1983 Match* parentMatch7 = &match;
1984 {
1985 long save = lexer.GetPos();
1986 Match match(false);
1987 Match* parentMatch8 = &match;
1988 {
1989 long save = lexer.GetPos();
1990 Match match(false);
1991 Match* parentMatch9 = &match;
1992 {
1993 long save = lexer.GetPos();
1994 Match match(false);
1995 Match* parentMatch10 = &match;
1996 {
1997 long save = lexer.GetPos();
1998 Match match(false);
1999 Match* parentMatch11 = &match;
2000 {
2001 long pos = lexer.GetPos();
2002 Match match(true);
2003 for (int i : s17)
2004 {
2005 if (*lexer == i)
2006 {
2007 ++lexer;
2008 }
2009 else
2010 {
2011 match.hit = false;
2012 break;
2013 }
2014 }
2015 if (match.hit)
2016 {
2017 {
2018 #if (DEBUG)
2019 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2020 #endif
2021 return Match(true, new Value<Month>(Month.january));
2022 }
2023 }
2024 *parentMatch11 = match;
2025 }
2026 *parentMatch10 = match;
2027 if (!match.hit)
2028 {
2029 Match match(false);
2030 Match* parentMatch12 = &match;
2031 lexer.SetPos(save);
2032 {
2033 Match match(false);
2034 Match* parentMatch13 = &match;
2035 {
2036 long pos = lexer.GetPos();
2037 Match match(true);
2038 for (int i : s18)
2039 {
2040 if (*lexer == i)
2041 {
2042 ++lexer;
2043 }
2044 else
2045 {
2046 match.hit = false;
2047 break;
2048 }
2049 }
2050 if (match.hit)
2051 {
2052 {
2053 #if (DEBUG)
2054 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2055 #endif
2056 return Match(true, new Value<Month>(Month.february));
2057 }
2058 }
2059 *parentMatch13 = match;
2060 }
2061 *parentMatch12 = match;
2062 }
2063 *parentMatch10 = match;
2064 }
2065 }
2066 *parentMatch9 = match;
2067 if (!match.hit)
2068 {
2069 Match match(false);
2070 Match* parentMatch14 = &match;
2071 lexer.SetPos(save);
2072 {
2073 Match match(false);
2074 Match* parentMatch15 = &match;
2075 {
2076 long pos = lexer.GetPos();
2077 Match match(true);
2078 for (int i : s19)
2079 {
2080 if (*lexer == i)
2081 {
2082 ++lexer;
2083 }
2084 else
2085 {
2086 match.hit = false;
2087 break;
2088 }
2089 }
2090 if (match.hit)
2091 {
2092 {
2093 #if (DEBUG)
2094 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2095 #endif
2096 return Match(true, new Value<Month>(Month.march));
2097 }
2098 }
2099 *parentMatch15 = match;
2100 }
2101 *parentMatch14 = match;
2102 }
2103 *parentMatch9 = match;
2104 }
2105 }
2106 *parentMatch8 = match;
2107 if (!match.hit)
2108 {
2109 Match match(false);
2110 Match* parentMatch16 = &match;
2111 lexer.SetPos(save);
2112 {
2113 Match match(false);
2114 Match* parentMatch17 = &match;
2115 {
2116 long pos = lexer.GetPos();
2117 Match match(true);
2118 for (int i : s20)
2119 {
2120 if (*lexer == i)
2121 {
2122 ++lexer;
2123 }
2124 else
2125 {
2126 match.hit = false;
2127 break;
2128 }
2129 }
2130 if (match.hit)
2131 {
2132 {
2133 #if (DEBUG)
2134 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2135 #endif
2136 return Match(true, new Value<Month>(Month.april));
2137 }
2138 }
2139 *parentMatch17 = match;
2140 }
2141 *parentMatch16 = match;
2142 }
2143 *parentMatch8 = match;
2144 }
2145 }
2146 *parentMatch7 = match;
2147 if (!match.hit)
2148 {
2149 Match match(false);
2150 Match* parentMatch18 = &match;
2151 lexer.SetPos(save);
2152 {
2153 Match match(false);
2154 Match* parentMatch19 = &match;
2155 {
2156 long pos = lexer.GetPos();
2157 Match match(true);
2158 for (int i : s21)
2159 {
2160 if (*lexer == i)
2161 {
2162 ++lexer;
2163 }
2164 else
2165 {
2166 match.hit = false;
2167 break;
2168 }
2169 }
2170 if (match.hit)
2171 {
2172 {
2173 #if (DEBUG)
2174 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2175 #endif
2176 return Match(true, new Value<Month>(Month.may));
2177 }
2178 }
2179 *parentMatch19 = match;
2180 }
2181 *parentMatch18 = match;
2182 }
2183 *parentMatch7 = match;
2184 }
2185 }
2186 *parentMatch6 = match;
2187 if (!match.hit)
2188 {
2189 Match match(false);
2190 Match* parentMatch20 = &match;
2191 lexer.SetPos(save);
2192 {
2193 Match match(false);
2194 Match* parentMatch21 = &match;
2195 {
2196 long pos = lexer.GetPos();
2197 Match match(true);
2198 for (int i : s22)
2199 {
2200 if (*lexer == i)
2201 {
2202 ++lexer;
2203 }
2204 else
2205 {
2206 match.hit = false;
2207 break;
2208 }
2209 }
2210 if (match.hit)
2211 {
2212 {
2213 #if (DEBUG)
2214 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2215 #endif
2216 return Match(true, new Value<Month>(Month.june));
2217 }
2218 }
2219 *parentMatch21 = match;
2220 }
2221 *parentMatch20 = match;
2222 }
2223 *parentMatch6 = match;
2224 }
2225 }
2226 *parentMatch5 = match;
2227 if (!match.hit)
2228 {
2229 Match match(false);
2230 Match* parentMatch22 = &match;
2231 lexer.SetPos(save);
2232 {
2233 Match match(false);
2234 Match* parentMatch23 = &match;
2235 {
2236 long pos = lexer.GetPos();
2237 Match match(true);
2238 for (int i : s23)
2239 {
2240 if (*lexer == i)
2241 {
2242 ++lexer;
2243 }
2244 else
2245 {
2246 match.hit = false;
2247 break;
2248 }
2249 }
2250 if (match.hit)
2251 {
2252 {
2253 #if (DEBUG)
2254 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2255 #endif
2256 return Match(true, new Value<Month>(Month.july));
2257 }
2258 }
2259 *parentMatch23 = match;
2260 }
2261 *parentMatch22 = match;
2262 }
2263 *parentMatch5 = match;
2264 }
2265 }
2266 *parentMatch4 = match;
2267 if (!match.hit)
2268 {
2269 Match match(false);
2270 Match* parentMatch24 = &match;
2271 lexer.SetPos(save);
2272 {
2273 Match match(false);
2274 Match* parentMatch25 = &match;
2275 {
2276 long pos = lexer.GetPos();
2277 Match match(true);
2278 for (int i : s24)
2279 {
2280 if (*lexer == i)
2281 {
2282 ++lexer;
2283 }
2284 else
2285 {
2286 match.hit = false;
2287 break;
2288 }
2289 }
2290 if (match.hit)
2291 {
2292 {
2293 #if (DEBUG)
2294 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2295 #endif
2296 return Match(true, new Value<Month>(Month.august));
2297 }
2298 }
2299 *parentMatch25 = match;
2300 }
2301 *parentMatch24 = match;
2302 }
2303 *parentMatch4 = match;
2304 }
2305 }
2306 *parentMatch3 = match;
2307 if (!match.hit)
2308 {
2309 Match match(false);
2310 Match* parentMatch26 = &match;
2311 lexer.SetPos(save);
2312 {
2313 Match match(false);
2314 Match* parentMatch27 = &match;
2315 {
2316 long pos = lexer.GetPos();
2317 Match match(true);
2318 for (int i : s25)
2319 {
2320 if (*lexer == i)
2321 {
2322 ++lexer;
2323 }
2324 else
2325 {
2326 match.hit = false;
2327 break;
2328 }
2329 }
2330 if (match.hit)
2331 {
2332 {
2333 #if (DEBUG)
2334 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2335 #endif
2336 return Match(true, new Value<Month>(Month.september));
2337 }
2338 }
2339 *parentMatch27 = match;
2340 }
2341 *parentMatch26 = match;
2342 }
2343 *parentMatch3 = match;
2344 }
2345 }
2346 *parentMatch2 = match;
2347 if (!match.hit)
2348 {
2349 Match match(false);
2350 Match* parentMatch28 = &match;
2351 lexer.SetPos(save);
2352 {
2353 Match match(false);
2354 Match* parentMatch29 = &match;
2355 {
2356 long pos = lexer.GetPos();
2357 Match match(true);
2358 for (int i : s26)
2359 {
2360 if (*lexer == i)
2361 {
2362 ++lexer;
2363 }
2364 else
2365 {
2366 match.hit = false;
2367 break;
2368 }
2369 }
2370 if (match.hit)
2371 {
2372 {
2373 #if (DEBUG)
2374 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2375 #endif
2376 return Match(true, new Value<Month>(Month.october));
2377 }
2378 }
2379 *parentMatch29 = match;
2380 }
2381 *parentMatch28 = match;
2382 }
2383 *parentMatch2 = match;
2384 }
2385 }
2386 *parentMatch1 = match;
2387 if (!match.hit)
2388 {
2389 Match match(false);
2390 Match* parentMatch30 = &match;
2391 lexer.SetPos(save);
2392 {
2393 Match match(false);
2394 Match* parentMatch31 = &match;
2395 {
2396 long pos = lexer.GetPos();
2397 Match match(true);
2398 for (int i : s27)
2399 {
2400 if (*lexer == i)
2401 {
2402 ++lexer;
2403 }
2404 else
2405 {
2406 match.hit = false;
2407 break;
2408 }
2409 }
2410 if (match.hit)
2411 {
2412 {
2413 #if (DEBUG)
2414 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2415 #endif
2416 return Match(true, new Value<Month>(Month.november));
2417 }
2418 }
2419 *parentMatch31 = match;
2420 }
2421 *parentMatch30 = match;
2422 }
2423 *parentMatch1 = match;
2424 }
2425 }
2426 *parentMatch0 = match;
2427 if (!match.hit)
2428 {
2429 Match match(false);
2430 Match* parentMatch32 = &match;
2431 lexer.SetPos(save);
2432 {
2433 Match match(false);
2434 Match* parentMatch33 = &match;
2435 {
2436 long pos = lexer.GetPos();
2437 Match match(true);
2438 for (int i : s28)
2439 {
2440 if (*lexer == i)
2441 {
2442 ++lexer;
2443 }
2444 else
2445 {
2446 match.hit = false;
2447 break;
2448 }
2449 }
2450 if (match.hit)
2451 {
2452 {
2453 #if (DEBUG)
2454 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2455 #endif
2456 return Match(true, new Value<Month>(Month.december));
2457 }
2458 }
2459 *parentMatch33 = match;
2460 }
2461 *parentMatch32 = match;
2462 }
2463 *parentMatch0 = match;
2464 }
2465 }
2466 #if (DEBUG)
2467 if (writeToLog)
2468 {
2469 if (match.hit)
2470 {
2471 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"month");
2472 }
2473 else
2474 {
2475 System.Lex.WriteFailureToLog(lexer, u"month");
2476 }
2477 }
2478 #endif
2479 if (!match.hit)
2480 {
2481 match.value = null;
2482 }
2483 return match;
2484 }
2485 public static Match time(TrivialLexer& lexer)
2486 {
2487 #if (DEBUG)
2488 Span debugSpan;
2489 bool writeToLog = lexer.Log() != null;
2490 if (writeToLog)
2491 {
2492 debugSpan = lexer.GetSpan();
2493 System.Lex.WriteBeginRuleToLog(lexer, u"time");
2494 }
2495 #endif
2496 UniquePtr<Value<int>> hour;
2497 UniquePtr<Value<int>> min;
2498 UniquePtr<Value<int>> sec;
2499 Match match(false);
2500 Match* parentMatch0 = &match;
2501 {
2502 long pos = lexer.GetPos();
2503 Match match(false);
2504 Match* parentMatch1 = &match;
2505 {
2506 Match match(false);
2507 Match* parentMatch2 = &match;
2508 {
2509 Match match(false);
2510 Match* parentMatch3 = &match;
2511 {
2512 Match match(false);
2513 Match* parentMatch4 = &match;
2514 {
2515 Match match(false);
2516 Match* parentMatch5 = &match;
2517 {
2518 Match match = HttpDateParser.Hour(lexer);
2519 hour.Reset(cast<Value<int>*>(match.value));
2520 *parentMatch5 = match;
2521 }
2522 if (match.hit)
2523 {
2524 Match match(false);
2525 Match* parentMatch6 = &match;
2526 {
2527 Match match(false);
2528 if (*lexer == 58)
2529 {
2530 ++lexer;
2531 match.hit = true;
2532 }
2533 *parentMatch6 = match;
2534 }
2535 *parentMatch5 = match;
2536 }
2537 *parentMatch4 = match;
2538 }
2539 if (match.hit)
2540 {
2541 Match match(false);
2542 Match* parentMatch7 = &match;
2543 {
2544 Match match = HttpDateParser.Min(lexer);
2545 min.Reset(cast<Value<int>*>(match.value));
2546 *parentMatch7 = match;
2547 }
2548 *parentMatch4 = match;
2549 }
2550 *parentMatch3 = match;
2551 }
2552 if (match.hit)
2553 {
2554 Match match(false);
2555 Match* parentMatch8 = &match;
2556 {
2557 Match match(false);
2558 if (*lexer == 58)
2559 {
2560 ++lexer;
2561 match.hit = true;
2562 }
2563 *parentMatch8 = match;
2564 }
2565 *parentMatch3 = match;
2566 }
2567 *parentMatch2 = match;
2568 }
2569 if (match.hit)
2570 {
2571 Match match(false);
2572 Match* parentMatch9 = &match;
2573 {
2574 Match match = HttpDateParser.Sec(lexer);
2575 sec.Reset(cast<Value<int>*>(match.value));
2576 *parentMatch9 = match;
2577 }
2578 *parentMatch2 = match;
2579 }
2580 *parentMatch1 = match;
2581 }
2582 if (match.hit)
2583 {
2584 {
2585 #if (DEBUG)
2586 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"time");
2587 #endif
2588 return Match(true, new Value<int>(3600 * hour->value + 60 * min->value + sec->value));
2589 }
2590 }
2591 *parentMatch0 = match;
2592 }
2593 #if (DEBUG)
2594 if (writeToLog)
2595 {
2596 if (match.hit)
2597 {
2598 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"time");
2599 }
2600 else
2601 {
2602 System.Lex.WriteFailureToLog(lexer, u"time");
2603 }
2604 }
2605 #endif
2606 if (!match.hit)
2607 {
2608 match.value = null;
2609 }
2610 return match;
2611 }
2612 public static Match Hour(TrivialLexer& lexer)
2613 {
2614 #if (DEBUG)
2615 Span debugSpan;
2616 bool writeToLog = lexer.Log() != null;
2617 if (writeToLog)
2618 {
2619 debugSpan = lexer.GetSpan();
2620 System.Lex.WriteBeginRuleToLog(lexer, u"Hour");
2621 }
2622 #endif
2623 ustring s;
2624 UniquePtr<Value<uchar>> d1;
2625 UniquePtr<Value<uchar>> d2;
2626 Match match(false);
2627 Match* parentMatch0 = &match;
2628 {
2629 long pos = lexer.GetPos();
2630 Match match(false);
2631 Match* parentMatch1 = &match;
2632 {
2633 Match match(false);
2634 Match* parentMatch2 = &match;
2635 {
2636 Match match(false);
2637 Match* parentMatch3 = &match;
2638 {
2639 long pos = lexer.GetPos();
2640 Match match = HttpDateParser.DIGIT(lexer);
2641 d1.Reset(cast<Value<uchar>*>(match.value));
2642 if (match.hit)
2643 {
2644 s.Append(d1->value);
2645 }
2646 *parentMatch3 = match;
2647 }
2648 *parentMatch2 = match;
2649 }
2650 if (match.hit)
2651 {
2652 Match match(false);
2653 Match* parentMatch4 = &match;
2654 {
2655 Match match(false);
2656 Match* parentMatch5 = &match;
2657 {
2658 long pos = lexer.GetPos();
2659 Match match = HttpDateParser.DIGIT(lexer);
2660 d2.Reset(cast<Value<uchar>*>(match.value));
2661 if (match.hit)
2662 {
2663 s.Append(d2->value);
2664 }
2665 *parentMatch5 = match;
2666 }
2667 *parentMatch4 = match;
2668 }
2669 *parentMatch2 = match;
2670 }
2671 *parentMatch1 = match;
2672 }
2673 if (match.hit)
2674 {
2675 {
2676 #if (DEBUG)
2677 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Hour");
2678 #endif
2679 return Match(true, new Value<int>(ParseInt(ToUtf8(s))));
2680 }
2681 }
2682 *parentMatch0 = match;
2683 }
2684 #if (DEBUG)
2685 if (writeToLog)
2686 {
2687 if (match.hit)
2688 {
2689 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Hour");
2690 }
2691 else
2692 {
2693 System.Lex.WriteFailureToLog(lexer, u"Hour");
2694 }
2695 }
2696 #endif
2697 if (!match.hit)
2698 {
2699 match.value = null;
2700 }
2701 return match;
2702 }
2703 public static Match Min(TrivialLexer& lexer)
2704 {
2705 #if (DEBUG)
2706 Span debugSpan;
2707 bool writeToLog = lexer.Log() != null;
2708 if (writeToLog)
2709 {
2710 debugSpan = lexer.GetSpan();
2711 System.Lex.WriteBeginRuleToLog(lexer, u"Min");
2712 }
2713 #endif
2714 ustring s;
2715 UniquePtr<Value<uchar>> d1;
2716 UniquePtr<Value<uchar>> d2;
2717 Match match(false);
2718 Match* parentMatch0 = &match;
2719 {
2720 long pos = lexer.GetPos();
2721 Match match(false);
2722 Match* parentMatch1 = &match;
2723 {
2724 Match match(false);
2725 Match* parentMatch2 = &match;
2726 {
2727 Match match(false);
2728 Match* parentMatch3 = &match;
2729 {
2730 long pos = lexer.GetPos();
2731 Match match = HttpDateParser.DIGIT(lexer);
2732 d1.Reset(cast<Value<uchar>*>(match.value));
2733 if (match.hit)
2734 {
2735 s.Append(d1->value);
2736 }
2737 *parentMatch3 = match;
2738 }
2739 *parentMatch2 = match;
2740 }
2741 if (match.hit)
2742 {
2743 Match match(false);
2744 Match* parentMatch4 = &match;
2745 {
2746 Match match(false);
2747 Match* parentMatch5 = &match;
2748 {
2749 long pos = lexer.GetPos();
2750 Match match = HttpDateParser.DIGIT(lexer);
2751 d2.Reset(cast<Value<uchar>*>(match.value));
2752 if (match.hit)
2753 {
2754 s.Append(d2->value);
2755 }
2756 *parentMatch5 = match;
2757 }
2758 *parentMatch4 = match;
2759 }
2760 *parentMatch2 = match;
2761 }
2762 *parentMatch1 = match;
2763 }
2764 if (match.hit)
2765 {
2766 {
2767 #if (DEBUG)
2768 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Min");
2769 #endif
2770 return Match(true, new Value<int>(ParseInt(ToUtf8(s))));
2771 }
2772 }
2773 *parentMatch0 = match;
2774 }
2775 #if (DEBUG)
2776 if (writeToLog)
2777 {
2778 if (match.hit)
2779 {
2780 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Min");
2781 }
2782 else
2783 {
2784 System.Lex.WriteFailureToLog(lexer, u"Min");
2785 }
2786 }
2787 #endif
2788 if (!match.hit)
2789 {
2790 match.value = null;
2791 }
2792 return match;
2793 }
2794 public static Match Sec(TrivialLexer& lexer)
2795 {
2796 #if (DEBUG)
2797 Span debugSpan;
2798 bool writeToLog = lexer.Log() != null;
2799 if (writeToLog)
2800 {
2801 debugSpan = lexer.GetSpan();
2802 System.Lex.WriteBeginRuleToLog(lexer, u"Sec");
2803 }
2804 #endif
2805 ustring s;
2806 UniquePtr<Value<uchar>> d1;
2807 UniquePtr<Value<uchar>> d2;
2808 Match match(false);
2809 Match* parentMatch0 = &match;
2810 {
2811 long pos = lexer.GetPos();
2812 Match match(false);
2813 Match* parentMatch1 = &match;
2814 {
2815 Match match(false);
2816 Match* parentMatch2 = &match;
2817 {
2818 Match match(false);
2819 Match* parentMatch3 = &match;
2820 {
2821 long pos = lexer.GetPos();
2822 Match match = HttpDateParser.DIGIT(lexer);
2823 d1.Reset(cast<Value<uchar>*>(match.value));
2824 if (match.hit)
2825 {
2826 s.Append(d1->value);
2827 }
2828 *parentMatch3 = match;
2829 }
2830 *parentMatch2 = match;
2831 }
2832 if (match.hit)
2833 {
2834 Match match(false);
2835 Match* parentMatch4 = &match;
2836 {
2837 Match match(false);
2838 Match* parentMatch5 = &match;
2839 {
2840 long pos = lexer.GetPos();
2841 Match match = HttpDateParser.DIGIT(lexer);
2842 d2.Reset(cast<Value<uchar>*>(match.value));
2843 if (match.hit)
2844 {
2845 s.Append(d2->value);
2846 }
2847 *parentMatch5 = match;
2848 }
2849 *parentMatch4 = match;
2850 }
2851 *parentMatch2 = match;
2852 }
2853 *parentMatch1 = match;
2854 }
2855 if (match.hit)
2856 {
2857 {
2858 #if (DEBUG)
2859 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Sec");
2860 #endif
2861 return Match(true, new Value<int>(ParseInt(ToUtf8(s))));
2862 }
2863 }
2864 *parentMatch0 = match;
2865 }
2866 #if (DEBUG)
2867 if (writeToLog)
2868 {
2869 if (match.hit)
2870 {
2871 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Sec");
2872 }
2873 else
2874 {
2875 System.Lex.WriteFailureToLog(lexer, u"Sec");
2876 }
2877 }
2878 #endif
2879 if (!match.hit)
2880 {
2881 match.value = null;
2882 }
2883 return match;
2884 }
2885 public static Match deltaSeconds(TrivialLexer& lexer)
2886 {
2887 #if (DEBUG)
2888 Span debugSpan;
2889 bool writeToLog = lexer.Log() != null;
2890 if (writeToLog)
2891 {
2892 debugSpan = lexer.GetSpan();
2893 System.Lex.WriteBeginRuleToLog(lexer, u"deltaSeconds");
2894 }
2895 #endif
2896 ustring s;
2897 UniquePtr<Value<uchar>> digit;
2898 Match match(false);
2899 Match* parentMatch0 = &match;
2900 {
2901 long pos = lexer.GetPos();
2902 Match match(false);
2903 Match* parentMatch1 = &match;
2904 {
2905 Match match(false);
2906 Match* parentMatch2 = &match;
2907 {
2908 Match match(false);
2909 Match* parentMatch3 = &match;
2910 {
2911 Match match(false);
2912 Match* parentMatch4 = &match;
2913 {
2914 long pos = lexer.GetPos();
2915 Match match = HttpDateParser.DIGIT(lexer);
2916 digit.Reset(cast<Value<uchar>*>(match.value));
2917 if (match.hit)
2918 {
2919 s.Append(digit->value);
2920 }
2921 *parentMatch4 = match;
2922 }
2923 *parentMatch3 = match;
2924 }
2925 *parentMatch2 = match;
2926 }
2927 if (match.hit)
2928 {
2929 Match match(true);
2930 Match* parentMatch5 = &match;
2931 while (true)
2932 {
2933 long save = lexer.GetPos();
2934 {
2935 Match match(false);
2936 Match* parentMatch6 = &match;
2937 {
2938 Match match(false);
2939 Match* parentMatch7 = &match;
2940 {
2941 long pos = lexer.GetPos();
2942 Match match = HttpDateParser.DIGIT(lexer);
2943 digit.Reset(cast<Value<uchar>*>(match.value));
2944 if (match.hit)
2945 {
2946 s.Append(digit->value);
2947 }
2948 *parentMatch7 = match;
2949 }
2950 *parentMatch6 = match;
2951 }
2952 if (match.hit)
2953 {
2954 *parentMatch5 = match;
2955 }
2956 else
2957 {
2958 lexer.SetPos(save);
2959 break;
2960 }
2961 }
2962 }
2963 }
2964 *parentMatch1 = match;
2965 }
2966 if (match.hit)
2967 {
2968 {
2969 #if (DEBUG)
2970 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"deltaSeconds");
2971 #endif
2972 return Match(true, new Value<int>(ParseInt(ToUtf8(s))));
2973 }
2974 }
2975 *parentMatch0 = match;
2976 }
2977 #if (DEBUG)
2978 if (writeToLog)
2979 {
2980 if (match.hit)
2981 {
2982 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"deltaSeconds");
2983 }
2984 else
2985 {
2986 System.Lex.WriteFailureToLog(lexer, u"deltaSeconds");
2987 }
2988 }
2989 #endif
2990 if (!match.hit)
2991 {
2992 match.value = null;
2993 }
2994 return match;
2995 }
2996 public static Match SP(TrivialLexer& lexer)
2997 {
2998 #if (DEBUG)
2999 Span debugSpan;
3000 bool writeToLog = lexer.Log() != null;
3001 if (writeToLog)
3002 {
3003 debugSpan = lexer.GetSpan();
3004 System.Lex.WriteBeginRuleToLog(lexer, u"SP");
3005 }
3006 #endif
3007 Match match(false);
3008 Match* parentMatch0 = &match;
3009 {
3010 long pos = lexer.GetPos();
3011 Match match(false);
3012 if (*lexer == 32)
3013 {
3014 ++lexer;
3015 match.hit = true;
3016 }
3017 if (match.hit)
3018 {
3019 {
3020 #if (DEBUG)
3021 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"SP");
3022 #endif
3023 return Match(true, new Value<uchar>(' '));
3024 }
3025 }
3026 *parentMatch0 = match;
3027 }
3028 #if (DEBUG)
3029 if (writeToLog)
3030 {
3031 if (match.hit)
3032 {
3033 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"SP");
3034 }
3035 else
3036 {
3037 System.Lex.WriteFailureToLog(lexer, u"SP");
3038 }
3039 }
3040 #endif
3041 if (!match.hit)
3042 {
3043 match.value = null;
3044 }
3045 return match;
3046 }
3047 public static Match DIGIT(TrivialLexer& lexer)
3048 {
3049 #if (DEBUG)
3050 Span debugSpan;
3051 bool writeToLog = lexer.Log() != null;
3052 if (writeToLog)
3053 {
3054 debugSpan = lexer.GetSpan();
3055 System.Lex.WriteBeginRuleToLog(lexer, u"DIGIT");
3056 }
3057 #endif
3058 Match match(false);
3059 Match* parentMatch0 = &match;
3060 {
3061 long pos = lexer.GetPos();
3062 Match match(false);
3063 for (const Range& range : s29)
3064 {
3065 if (*lexer >= range.first && *lexer <= range.last)
3066 {
3067 match.hit = true;
3068 ++lexer;
3069 break;
3070 }
3071 }
3072 if (match.hit)
3073 {
3074 {
3075 #if (DEBUG)
3076 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"DIGIT");
3077 #endif
3078 return Match(true, new Value<uchar>(lexer.GetUChar(pos)));
3079 }
3080 }
3081 *parentMatch0 = match;
3082 }
3083 #if (DEBUG)
3084 if (writeToLog)
3085 {
3086 if (match.hit)
3087 {
3088 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"DIGIT");
3089 }
3090 else
3091 {
3092 System.Lex.WriteFailureToLog(lexer, u"DIGIT");
3093 }
3094 }
3095 #endif
3096 if (!match.hit)
3097 {
3098 match.value = null;
3099 }
3100 return match;
3101 }
3102 }