]> Git — Sourcephile - haskell/symantic-parser.git/blob - test/Golden/Splice/G14.expected.txt
sourcephile / git / haskell / symantic-parser.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
test: dump splices using TH.runQ instead of calling ghc
[haskell/symantic-parser.git] / test / Golden / Splice / G14.expected.txt
1 \(input :: inp) ->
2 let !(#
3 init,
4 readMore,
5 readNext
6 #) =
7 let _ = "cursorOf"
8 in let next
9 ( t@( Data.Text.Internal.Text
10 arr
11 off
12 unconsumed
13 )
14 ) =
15 let !( Data.Text.Unsafe.Iter
16 c
17 d
18 ) = Data.Text.Unsafe.iter t 0
19 in (#
20 c,
21 Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)
22 #)
23 more
24 ( Data.Text.Internal.Text
25 _
26 _
27 unconsumed
28 ) = unconsumed GHC.Classes.> 0
29 in (# input, more, next #)
30 in let finalRet = \_farInp _farExp v _inp -> Data.Either.Right v
31 in let finalRaise ::
32 forall b.
33 Symantic.Parser.Machine.Generate.Catcher
34 inp
35 b = \_failInp (!farInp) (!farExp) ->
36 Data.Either.Left
37 Symantic.Parser.Machine.Generate.ParsingErrorStandard
38 { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,
39 Symantic.Parser.Machine.Generate.parsingErrorUnexpected =
40 if readMore farInp
41 then
42 GHC.Maybe.Just
43 ( let (#
44 c,
45 _
46 #) = readNext farInp
47 in c
48 )
49 else GHC.Maybe.Nothing,
50 Symantic.Parser.Machine.Generate.parsingErrorExpecting = Data.Set.Internal.fromList farExp
51 }
52 in let name = \(!ok) (!inp) (!koByLabel) ->
53 name
54 ( let _ = "suspend"
55 in \farInp farExp v (!inp) ->
56 name
57 ( let _ = "suspend"
58 in \farInp farExp v (!inp) ->
59 name
60 ( let _ = "suspend"
61 in \farInp farExp v (!inp) ->
62 name
63 ( let _ = "suspend"
64 in \farInp farExp v (!inp) ->
65 let _ = "resume"
66 in ok
67 farInp
68 farExp
69 ( let _ = "resume.genCode"
70 in v
71 )
72 inp
73 )
74 inp
75 Data.Map.Internal.Tip
76 )
77 inp
78 Data.Map.Internal.Tip
79 )
80 inp
81 Data.Map.Internal.Tip
82 )
83 inp
84 Data.Map.Internal.Tip
85 name = \(!ok) (!inp) (!koByLabel) ->
86 name
87 ( let _ = "suspend"
88 in \farInp farExp v (!inp) ->
89 name
90 ( let _ = "suspend"
91 in \farInp farExp v (!inp) ->
92 let _ = "resume"
93 in ok
94 farInp
95 farExp
96 ( let _ = "resume.genCode"
97 in GHC.Tuple . ()
98 )
99 inp
100 )
101 inp
102 Data.Map.Internal.Tip
103 )
104 inp
105 (Data.Map.Internal.Bin 1 "fail" (Data.Map.Strict.Internal.findWithDefault finalRaise "fail" koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
106 name = \(!ok) (!inp) (!koByLabel) ->
107 name
108 ( let _ = "suspend"
109 in \farInp farExp v (!inp) ->
110 let join = \farInp farExp v (!inp) ->
111 let _ = "resume"
112 in ok
113 farInp
114 farExp
115 ( let _ = "resume.genCode"
116 in v
117 )
118 inp
119 in let _ = "catchException lbl=fail"
120 in let catchHandler (!failInp) (!farInp) (!farExp) =
121 let _ = "catchException.ko lbl=fail"
122 in if ( \( Data.Text.Internal.Text
123 _
124 i
125 _
126 )
127 ( Data.Text.Internal.Text
128 _
129 j
130 _
131 ) -> i GHC.Classes.== j
132 )
133 inp
134 failInp
135 then
136 let _ = "choicesBranch.then"
137 in name
138 ( let _ = "suspend"
139 in \farInp farExp v (!inp) ->
140 let _ = "resume"
141 in join
142 farInp
143 farExp
144 ( let _ = "resume.genCode"
145 in v
146 )
147 inp
148 )
149 failInp
150 Data.Map.Internal.Tip
151 else
152 let _ = "choicesBranch.else"
153 in let (#
154 farInp,
155 farExp
156 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
157 GHC.Types.LT ->
158 (#
159 failInp,
160 []
161 #)
162 GHC.Types.EQ ->
163 (#
164 farInp,
165 farExp GHC.Base.<> []
166 #)
167 GHC.Types.GT ->
168 (#
169 farInp,
170 farExp
171 #)
172 in finalRaise failInp farInp farExp
173 in name
174 ( let _ = "suspend"
175 in \farInp farExp v (!inp) ->
176 let _ = "resume"
177 in join
178 farInp
179 farExp
180 ( let _ = "resume.genCode"
181 in GHC.Tuple . ()
182 )
183 inp
184 )
185 inp
186 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
187 )
188 inp
189 Data.Map.Internal.Tip
190 name = \(!ok) (!inp) (!koByLabel) ->
191 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise "fail" koByLabel
192 in if readMore inp
193 then
194 let !(#
195 c,
196 cs
197 #) = readNext inp
198 in if GHC.Unicode.isSpace c
199 then
200 name
201 ( let _ = "suspend"
202 in \farInp farExp v (!inp) ->
203 let _ = "resume"
204 in ok
205 farInp
206 farExp
207 ( let _ = "resume.genCode"
208 in v
209 )
210 inp
211 )
212 cs
213 Data.Map.Internal.Tip
214 else
215 let _ = "checkToken.else"
216 in let (#
217 farInp,
218 farExp
219 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
220 GHC.Types.LT ->
221 (#
222 inp,
223 [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "space"]
224 #)
225 GHC.Types.EQ ->
226 (#
227 init,
228 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "space"]
229 #)
230 GHC.Types.GT ->
231 (#
232 init,
233 GHC.Types . []
234 #)
235 in readFail inp farInp farExp
236 else
237 let _ = "checkHorizon.else"
238 in let (#
239 farInp,
240 farExp
241 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
242 GHC.Types.LT ->
243 (#
244 inp,
245 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
246 #)
247 GHC.Types.EQ ->
248 (#
249 init,
250 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
251 #)
252 GHC.Types.GT ->
253 (#
254 init,
255 GHC.Types . []
256 #)
257 in readFail inp farInp farExp
258 name = \(!ok) (!inp) (!koByLabel) ->
259 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise "fail" koByLabel
260 in if readMore inp
261 then
262 let !(#
263 c,
264 cs
265 #) = readNext inp
266 in if (\t -> ('0' GHC.Classes.== t) GHC.Classes.|| (('1' GHC.Classes.== t) GHC.Classes.|| (('2' GHC.Classes.== t) GHC.Classes.|| (('3' GHC.Classes.== t) GHC.Classes.|| (('4' GHC.Classes.== t) GHC.Classes.|| (('5' GHC.Classes.== t) GHC.Classes.|| (('6' GHC.Classes.== t) GHC.Classes.|| (('7' GHC.Classes.== t) GHC.Classes.|| (('8' GHC.Classes.== t) GHC.Classes.|| (('9' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))))))))) c
267 then
268 let _ = "resume"
269 in ok init GHC.Types
270 . []
271 ( let _ = "resume.genCode"
272 in c
273 )
274 cs
275 else
276 let _ = "checkToken.else"
277 in let (#
278 farInp,
279 farExp
280 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
281 GHC.Types.LT ->
282 (#
283 inp,
284 [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "oneOf"]
285 #)
286 GHC.Types.EQ ->
287 (#
288 init,
289 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "oneOf"]
290 #)
291 GHC.Types.GT ->
292 (#
293 init,
294 GHC.Types . []
295 #)
296 in readFail inp farInp farExp
297 else
298 let _ = "checkHorizon.else"
299 in let (#
300 farInp,
301 farExp
302 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
303 GHC.Types.LT ->
304 (#
305 inp,
306 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
307 #)
308 GHC.Types.EQ ->
309 (#
310 init,
311 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
312 #)
313 GHC.Types.GT ->
314 (#
315 init,
316 GHC.Types . []
317 #)
318 in readFail inp farInp farExp
319 name = \(!ok) (!inp) (!koByLabel) ->
320 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise "fail" koByLabel
321 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
322 then
323 let !(#
324 c,
325 cs
326 #) = readNext inp
327 in if ('(' GHC.Classes.==) c
328 then
329 name
330 ( let _ = "suspend"
331 in \farInp farExp v (!inp) ->
332 let _ = "resume"
333 in ok
334 farInp
335 farExp
336 ( let _ = "resume.genCode"
337 in '('
338 )
339 inp
340 )
341 cs
342 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
343 else
344 let _ = "checkToken.else"
345 in let (#
346 farInp,
347 farExp
348 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
349 GHC.Types.LT ->
350 (#
351 inp,
352 [Symantic.Parser.Grammar.Combinators.ErrorItemToken '(']
353 #)
354 GHC.Types.EQ ->
355 (#
356 init,
357 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken '(']
358 #)
359 GHC.Types.GT ->
360 (#
361 init,
362 GHC.Types . []
363 #)
364 in readFail inp farInp farExp
365 else
366 let _ = "checkHorizon.else"
367 in let (#
368 farInp,
369 farExp
370 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
371 GHC.Types.LT ->
372 (#
373 inp,
374 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
375 #)
376 GHC.Types.EQ ->
377 (#
378 init,
379 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
380 #)
381 GHC.Types.GT ->
382 (#
383 init,
384 GHC.Types . []
385 #)
386 in readFail inp farInp farExp
387 name = \(!ok) (!inp) (!koByLabel) ->
388 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise "fail" koByLabel
389 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
390 then
391 let !(#
392 c,
393 cs
394 #) = readNext inp
395 in if (')' GHC.Classes.==) c
396 then
397 name
398 ( let _ = "suspend"
399 in \farInp farExp v (!inp) ->
400 let _ = "resume"
401 in ok
402 farInp
403 farExp
404 ( let _ = "resume.genCode"
405 in ')'
406 )
407 inp
408 )
409 cs
410 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
411 else
412 let _ = "checkToken.else"
413 in let (#
414 farInp,
415 farExp
416 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
417 GHC.Types.LT ->
418 (#
419 inp,
420 [Symantic.Parser.Grammar.Combinators.ErrorItemToken ')']
421 #)
422 GHC.Types.EQ ->
423 (#
424 init,
425 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken ')']
426 #)
427 GHC.Types.GT ->
428 (#
429 init,
430 GHC.Types . []
431 #)
432 in readFail inp farInp farExp
433 else
434 let _ = "checkHorizon.else"
435 in let (#
436 farInp,
437 farExp
438 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
439 GHC.Types.LT ->
440 (#
441 inp,
442 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
443 #)
444 GHC.Types.EQ ->
445 (#
446 init,
447 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
448 #)
449 GHC.Types.GT ->
450 (#
451 init,
452 GHC.Types . []
453 #)
454 in readFail inp farInp farExp
455 name = \(!ok) (!inp) (!koByLabel) ->
456 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise "fail" koByLabel
457 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
458 then
459 let !(#
460 c,
461 cs
462 #) = readNext inp
463 in if (',' GHC.Classes.==) c
464 then
465 name
466 ( let _ = "suspend"
467 in \farInp farExp v (!inp) ->
468 let _ = "resume"
469 in ok
470 farInp
471 farExp
472 ( let _ = "resume.genCode"
473 in ','
474 )
475 inp
476 )
477 cs
478 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
479 else
480 let _ = "checkToken.else"
481 in let (#
482 farInp,
483 farExp
484 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
485 GHC.Types.LT ->
486 (#
487 inp,
488 [Symantic.Parser.Grammar.Combinators.ErrorItemToken ',']
489 #)
490 GHC.Types.EQ ->
491 (#
492 init,
493 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken ',']
494 #)
495 GHC.Types.GT ->
496 (#
497 init,
498 GHC.Types . []
499 #)
500 in readFail inp farInp farExp
501 else
502 let _ = "checkHorizon.else"
503 in let (#
504 farInp,
505 farExp
506 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
507 GHC.Types.LT ->
508 (#
509 inp,
510 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
511 #)
512 GHC.Types.EQ ->
513 (#
514 init,
515 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
516 #)
517 GHC.Types.GT ->
518 (#
519 init,
520 GHC.Types . []
521 #)
522 in readFail inp farInp farExp
523 name = \(!ok) (!inp) (!koByLabel) ->
524 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise "fail" koByLabel
525 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
526 then
527 let !(#
528 c,
529 cs
530 #) = readNext inp
531 in if (';' GHC.Classes.==) c
532 then
533 name
534 ( let _ = "suspend"
535 in \farInp farExp v (!inp) ->
536 let _ = "resume"
537 in ok
538 farInp
539 farExp
540 ( let _ = "resume.genCode"
541 in ';'
542 )
543 inp
544 )
545 cs
546 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
547 else
548 let _ = "checkToken.else"
549 in let (#
550 farInp,
551 farExp
552 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
553 GHC.Types.LT ->
554 (#
555 inp,
556 [Symantic.Parser.Grammar.Combinators.ErrorItemToken ';']
557 #)
558 GHC.Types.EQ ->
559 (#
560 init,
561 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken ';']
562 #)
563 GHC.Types.GT ->
564 (#
565 init,
566 GHC.Types . []
567 #)
568 in readFail inp farInp farExp
569 else
570 let _ = "checkHorizon.else"
571 in let (#
572 farInp,
573 farExp
574 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
575 GHC.Types.LT ->
576 (#
577 inp,
578 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
579 #)
580 GHC.Types.EQ ->
581 (#
582 init,
583 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
584 #)
585 GHC.Types.GT ->
586 (#
587 init,
588 GHC.Types . []
589 #)
590 in readFail inp farInp farExp
591 name = \(!ok) (!inp) (!koByLabel) ->
592 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise "fail" koByLabel
593 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)
594 then
595 let !(#
596 c,
597 cs
598 #) = readNext inp
599 in if ('{' GHC.Classes.==) c
600 then
601 name
602 ( let _ = "suspend"
603 in \farInp farExp v (!inp) ->
604 name
605 ( let _ = "suspend"
606 in \farInp farExp v (!inp) ->
607 name
608 ( let _ = "suspend"
609 in \farInp farExp v (!inp) ->
610 name
611 ( let _ = "suspend"
612 in \farInp farExp v (!inp) ->
613 let readFail = readFail
614 in if readMore inp
615 then
616 let !(#
617 c,
618 cs
619 #) = readNext inp
620 in if ('}' GHC.Classes.==) c
621 then
622 name
623 ( let _ = "suspend"
624 in \farInp farExp v (!inp) ->
625 let _ = "resume"
626 in ok
627 farInp
628 farExp
629 ( let _ = "resume.genCode"
630 in v
631 )
632 inp
633 )
634 cs
635 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
636 else
637 let _ = "checkToken.else"
638 in let (#
639 farInp,
640 farExp
641 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
642 GHC.Types.LT ->
643 (#
644 inp,
645 [Symantic.Parser.Grammar.Combinators.ErrorItemToken '}']
646 #)
647 GHC.Types.EQ ->
648 (#
649 farInp,
650 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken '}']
651 #)
652 GHC.Types.GT ->
653 (#
654 farInp,
655 farExp
656 #)
657 in readFail inp farInp farExp
658 else
659 let _ = "checkHorizon.else"
660 in let (#
661 farInp,
662 farExp
663 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
664 GHC.Types.LT ->
665 (#
666 inp,
667 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
668 #)
669 GHC.Types.EQ ->
670 (#
671 farInp,
672 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
673 #)
674 GHC.Types.GT ->
675 (#
676 farInp,
677 farExp
678 #)
679 in readFail inp farInp farExp
680 )
681 inp
682 Data.Map.Internal.Tip
683 )
684 inp
685 Data.Map.Internal.Tip
686 )
687 inp
688 Data.Map.Internal.Tip
689 )
690 cs
691 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
692 else
693 let _ = "checkToken.else"
694 in let (#
695 farInp,
696 farExp
697 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
698 GHC.Types.LT ->
699 (#
700 inp,
701 [Symantic.Parser.Grammar.Combinators.ErrorItemToken '{']
702 #)
703 GHC.Types.EQ ->
704 (#
705 init,
706 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken '{']
707 #)
708 GHC.Types.GT ->
709 (#
710 init,
711 GHC.Types . []
712 #)
713 in readFail inp farInp farExp
714 else
715 let _ = "checkHorizon.else"
716 in let (#
717 farInp,
718 farExp
719 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
720 GHC.Types.LT ->
721 (#
722 inp,
723 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 4]
724 #)
725 GHC.Types.EQ ->
726 (#
727 init,
728 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 4]
729 #)
730 GHC.Types.GT ->
731 (#
732 init,
733 GHC.Types . []
734 #)
735 in readFail inp farInp farExp
736 name = \(!ok) (!inp) (!koByLabel) ->
737 let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise "fail" koByLabel
738 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 4 inp)
739 then
740 let !(#
741 c,
742 cs
743 #) = readNext inp
744 in if ('[' GHC.Classes.==) c
745 then
746 name
747 ( let _ = "suspend"
748 in \farInp farExp v (!inp) ->
749 name
750 ( let _ = "suspend"
751 in \farInp farExp v (!inp) ->
752 name
753 ( let _ = "suspend"
754 in \farInp farExp v (!inp) ->
755 let readFail = readFail
756 in if readMore inp
757 then
758 let !(#
759 c,
760 cs
761 #) = readNext inp
762 in if (']' GHC.Classes.==) c
763 then
764 name
765 ( let _ = "suspend"
766 in \farInp farExp v (!inp) ->
767 let _ = "resume"
768 in ok
769 farInp
770 farExp
771 ( let _ = "resume.genCode"
772 in GHC.Tuple . ()
773 )
774 inp
775 )
776 cs
777 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
778 else
779 let _ = "checkToken.else"
780 in let (#
781 farInp,
782 farExp
783 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
784 GHC.Types.LT ->
785 (#
786 inp,
787 [Symantic.Parser.Grammar.Combinators.ErrorItemToken ']']
788 #)
789 GHC.Types.EQ ->
790 (#
791 farInp,
792 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken ']']
793 #)
794 GHC.Types.GT ->
795 (#
796 farInp,
797 farExp
798 #)
799 in readFail inp farInp farExp
800 else
801 let _ = "checkHorizon.else"
802 in let (#
803 farInp,
804 farExp
805 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
806 GHC.Types.LT ->
807 (#
808 inp,
809 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
810 #)
811 GHC.Types.EQ ->
812 (#
813 farInp,
814 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
815 #)
816 GHC.Types.GT ->
817 (#
818 farInp,
819 farExp
820 #)
821 in readFail inp farInp farExp
822 )
823 inp
824 Data.Map.Internal.Tip
825 )
826 inp
827 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
828 )
829 cs
830 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
831 else
832 let _ = "checkToken.else"
833 in let (#
834 farInp,
835 farExp
836 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
837 GHC.Types.LT ->
838 (#
839 inp,
840 [Symantic.Parser.Grammar.Combinators.ErrorItemToken '[']
841 #)
842 GHC.Types.EQ ->
843 (#
844 init,
845 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken '[']
846 #)
847 GHC.Types.GT ->
848 (#
849 init,
850 GHC.Types . []
851 #)
852 in readFail inp farInp farExp
853 else
854 let _ = "checkHorizon.else"
855 in let (#
856 farInp,
857 farExp
858 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
859 GHC.Types.LT ->
860 (#
861 inp,
862 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 5]
863 #)
864 GHC.Types.EQ ->
865 (#
866 init,
867 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 5]
868 #)
869 GHC.Types.GT ->
870 (#
871 init,
872 GHC.Types . []
873 #)
874 in readFail inp farInp farExp
875 name = \(!ok) (!inp) (!koByLabel) ->
876 let _ = "catchException lbl=fail"
877 in let catchHandler (!failInp) (!farInp) (!farExp) =
878 let _ = "catchException.ko lbl=fail"
879 in if ( \( Data.Text.Internal.Text
880 _
881 i
882 _
883 )
884 ( Data.Text.Internal.Text
885 _
886 j
887 _
888 ) -> i GHC.Classes.== j
889 )
890 inp
891 failInp
892 then
893 let _ = "choicesBranch.then"
894 in name
895 ( let _ = "suspend"
896 in \farInp farExp v (!inp) ->
897 let join = \farInp farExp v (!inp) ->
898 let _ = "resume"
899 in ok
900 farInp
901 farExp
902 ( let _ = "resume.genCode"
903 in v
904 )
905 inp
906 in let _ = "catchException lbl=fail"
907 in let catchHandler (!failInp) (!farInp) (!farExp) =
908 let _ = "catchException.ko lbl=fail"
909 in if ( \( Data.Text.Internal.Text
910 _
911 i
912 _
913 )
914 ( Data.Text.Internal.Text
915 _
916 j
917 _
918 ) -> i GHC.Classes.== j
919 )
920 inp
921 failInp
922 then
923 let _ = "choicesBranch.then"
924 in name
925 ( let _ = "suspend"
926 in \farInp farExp v (!inp) ->
927 let _ = "resume"
928 in join
929 farInp
930 farExp
931 ( let _ = "resume.genCode"
932 in v
933 )
934 inp
935 )
936 failInp
937 Data.Map.Internal.Tip
938 else
939 let _ = "choicesBranch.else"
940 in let (#
941 farInp,
942 farExp
943 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
944 GHC.Types.LT ->
945 (#
946 failInp,
947 []
948 #)
949 GHC.Types.EQ ->
950 (#
951 farInp,
952 farExp GHC.Base.<> []
953 #)
954 GHC.Types.GT ->
955 (#
956 farInp,
957 farExp
958 #)
959 in finalRaise failInp farInp farExp
960 in let join = \farInp farExp v (!inp) ->
961 let _ = "resume"
962 in join
963 farInp
964 farExp
965 ( let _ = "resume.genCode"
966 in GHC.Tuple . ()
967 )
968 inp
969 in let _ = "catchException lbl=fail"
970 in let catchHandler (!failInp) (!farInp) (!farExp) =
971 let _ = "catchException.ko lbl=fail"
972 in if ( \( Data.Text.Internal.Text
973 _
974 i
975 _
976 )
977 ( Data.Text.Internal.Text
978 _
979 j
980 _
981 ) -> i GHC.Classes.== j
982 )
983 inp
984 failInp
985 then
986 let _ = "choicesBranch.then"
987 in name
988 ( let _ = "suspend"
989 in \farInp farExp v (!inp) ->
990 let _ = "resume"
991 in join
992 farInp
993 farExp
994 ( let _ = "resume.genCode"
995 in v
996 )
997 inp
998 )
999 failInp
1000 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1001 else
1002 let _ = "choicesBranch.else"
1003 in let (#
1004 farInp,
1005 farExp
1006 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1007 GHC.Types.LT ->
1008 (#
1009 failInp,
1010 []
1011 #)
1012 GHC.Types.EQ ->
1013 (#
1014 farInp,
1015 farExp GHC.Base.<> []
1016 #)
1017 GHC.Types.GT ->
1018 (#
1019 farInp,
1020 farExp
1021 #)
1022 in catchHandler failInp farInp farExp
1023 in name
1024 ( let _ = "suspend"
1025 in \farInp farExp v (!inp) ->
1026 let join = \farInp farExp v (!inp) ->
1027 name
1028 ( let _ = "suspend"
1029 in \farInp farExp v (!inp) ->
1030 let _ = "resume"
1031 in join
1032 farInp
1033 farExp
1034 ( let _ = "resume.genCode"
1035 in v
1036 )
1037 inp
1038 )
1039 inp
1040 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1041 in let _ = "catchException lbl=fail"
1042 in let catchHandler (!failInp) (!farInp) (!farExp) =
1043 let _ = "catchException.ko lbl=fail"
1044 in if ( \( Data.Text.Internal.Text
1045 _
1046 i
1047 _
1048 )
1049 ( Data.Text.Internal.Text
1050 _
1051 j
1052 _
1053 ) -> i GHC.Classes.== j
1054 )
1055 inp
1056 failInp
1057 then
1058 let _ = "choicesBranch.then"
1059 in name
1060 ( let _ = "suspend"
1061 in \farInp farExp v (!inp) ->
1062 let _ = "resume"
1063 in join
1064 farInp
1065 farExp
1066 ( let _ = "resume.genCode"
1067 in v
1068 )
1069 inp
1070 )
1071 failInp
1072 Data.Map.Internal.Tip
1073 else
1074 let _ = "choicesBranch.else"
1075 in let (#
1076 farInp,
1077 farExp
1078 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1079 GHC.Types.LT ->
1080 (#
1081 failInp,
1082 []
1083 #)
1084 GHC.Types.EQ ->
1085 (#
1086 farInp,
1087 farExp GHC.Base.<> []
1088 #)
1089 GHC.Types.GT ->
1090 (#
1091 farInp,
1092 farExp
1093 #)
1094 in catchHandler failInp farInp farExp
1095 in name
1096 ( let _ = "suspend"
1097 in \farInp farExp v (!inp) ->
1098 name
1099 ( let _ = "suspend"
1100 in \farInp farExp v (!inp) ->
1101 name
1102 ( let _ = "suspend"
1103 in \farInp farExp v (!inp) ->
1104 name
1105 ( let _ = "suspend"
1106 in \farInp farExp v (!inp) ->
1107 let _ = "resume"
1108 in join
1109 farInp
1110 farExp
1111 ( let _ = "resume.genCode"
1112 in GHC.Tuple . ()
1113 )
1114 inp
1115 )
1116 inp
1117 Data.Map.Internal.Tip
1118 )
1119 inp
1120 Data.Map.Internal.Tip
1121 )
1122 inp
1123 Data.Map.Internal.Tip
1124 )
1125 inp
1126 Data.Map.Internal.Tip
1127 )
1128 inp
1129 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1130 )
1131 failInp
1132 Data.Map.Internal.Tip
1133 else
1134 let _ = "choicesBranch.else"
1135 in let (#
1136 farInp,
1137 farExp
1138 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1139 GHC.Types.LT ->
1140 (#
1141 failInp,
1142 []
1143 #)
1144 GHC.Types.EQ ->
1145 (#
1146 farInp,
1147 farExp GHC.Base.<> []
1148 #)
1149 GHC.Types.GT ->
1150 (#
1151 farInp,
1152 farExp
1153 #)
1154 in finalRaise failInp farInp farExp
1155 in let join = \farInp farExp v (!inp) ->
1156 let _ = "resume"
1157 in ok
1158 farInp
1159 farExp
1160 ( let _ = "resume.genCode"
1161 in v
1162 )
1163 inp
1164 in let _ = "catchException lbl=fail"
1165 in let catchHandler (!failInp) (!farInp) (!farExp) =
1166 let _ = "catchException.ko lbl=fail"
1167 in if ( \( Data.Text.Internal.Text
1168 _
1169 i
1170 _
1171 )
1172 ( Data.Text.Internal.Text
1173 _
1174 j
1175 _
1176 ) -> i GHC.Classes.== j
1177 )
1178 inp
1179 failInp
1180 then
1181 let _ = "choicesBranch.then"
1182 in let readFail = catchHandler
1183 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 failInp)
1184 then
1185 let !(#
1186 c,
1187 cs
1188 #) = readNext failInp
1189 in if ('\'' GHC.Classes.==) c
1190 then
1191 let join = \farInp farExp v (!inp) ->
1192 let readFail = readFail
1193 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
1194 then
1195 let !(#
1196 c,
1197 cs
1198 #) = readNext inp
1199 in if ('\'' GHC.Classes.==) c
1200 then
1201 name
1202 ( let _ = "suspend"
1203 in \farInp farExp v (!inp) ->
1204 let _ = "resume"
1205 in join
1206 farInp
1207 farExp
1208 ( let _ = "resume.genCode"
1209 in v
1210 )
1211 inp
1212 )
1213 cs
1214 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
1215 else
1216 let _ = "checkToken.else"
1217 in let (#
1218 farInp,
1219 farExp
1220 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
1221 GHC.Types.LT ->
1222 (#
1223 inp,
1224 [Symantic.Parser.Grammar.Combinators.ErrorItemToken '\'']
1225 #)
1226 GHC.Types.EQ ->
1227 (#
1228 farInp,
1229 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken '\'']
1230 #)
1231 GHC.Types.GT ->
1232 (#
1233 farInp,
1234 farExp
1235 #)
1236 in readFail inp farInp farExp
1237 else
1238 let _ = "checkHorizon.else"
1239 in let (#
1240 farInp,
1241 farExp
1242 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
1243 GHC.Types.LT ->
1244 (#
1245 inp,
1246 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
1247 #)
1248 GHC.Types.EQ ->
1249 (#
1250 farInp,
1251 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
1252 #)
1253 GHC.Types.GT ->
1254 (#
1255 farInp,
1256 farExp
1257 #)
1258 in readFail inp farInp farExp
1259 in let _ = "catchException lbl=fail"
1260 in let catchHandler (!failInp) (!farInp) (!farExp) =
1261 let _ = "catchException.ko lbl=fail"
1262 in if ( \( Data.Text.Internal.Text
1263 _
1264 i
1265 _
1266 )
1267 ( Data.Text.Internal.Text
1268 _
1269 j
1270 _
1271 ) -> i GHC.Classes.== j
1272 )
1273 cs
1274 failInp
1275 then
1276 let _ = "choicesBranch.then"
1277 in let readFail = readFail
1278 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 failInp)
1279 then
1280 let !(#
1281 c,
1282 cs
1283 #) = readNext failInp
1284 in if ('\\' GHC.Classes.==) c
1285 then
1286 let readFail = readFail
1287 in let !(#
1288 c,
1289 cs
1290 #) = readNext cs
1291 in if (\t -> ('0' GHC.Classes.== t) GHC.Classes.|| (('t' GHC.Classes.== t) GHC.Classes.|| (('n' GHC.Classes.== t) GHC.Classes.|| (('v' GHC.Classes.== t) GHC.Classes.|| (('f' GHC.Classes.== t) GHC.Classes.|| (('r' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))))) c
1292 then
1293 name
1294 ( let _ = "suspend"
1295 in \farInp farExp v (!inp) ->
1296 let _ = "resume"
1297 in join
1298 farInp
1299 farExp
1300 ( let _ = "resume.genCode"
1301 in v
1302 )
1303 inp
1304 )
1305 cs
1306 Data.Map.Internal.Tip
1307 else
1308 let _ = "checkToken.else"
1309 in let (#
1310 farInp,
1311 farExp
1312 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
1313 GHC.Types.LT ->
1314 (#
1315 cs,
1316 [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "oneOf"]
1317 #)
1318 GHC.Types.EQ ->
1319 (#
1320 farInp,
1321 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "oneOf"]
1322 #)
1323 GHC.Types.GT ->
1324 (#
1325 farInp,
1326 farExp
1327 #)
1328 in readFail cs farInp farExp
1329 else
1330 let _ = "checkToken.else"
1331 in let (#
1332 farInp,
1333 farExp
1334 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1335 GHC.Types.LT ->
1336 (#
1337 failInp,
1338 [Symantic.Parser.Grammar.Combinators.ErrorItemToken '\\']
1339 #)
1340 GHC.Types.EQ ->
1341 (#
1342 farInp,
1343 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken '\\']
1344 #)
1345 GHC.Types.GT ->
1346 (#
1347 farInp,
1348 farExp
1349 #)
1350 in readFail failInp farInp farExp
1351 else
1352 let _ = "checkHorizon.else"
1353 in let (#
1354 farInp,
1355 farExp
1356 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1357 GHC.Types.LT ->
1358 (#
1359 failInp,
1360 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 4]
1361 #)
1362 GHC.Types.EQ ->
1363 (#
1364 farInp,
1365 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 4]
1366 #)
1367 GHC.Types.GT ->
1368 (#
1369 farInp,
1370 farExp
1371 #)
1372 in readFail failInp farInp farExp
1373 else
1374 let _ = "choicesBranch.else"
1375 in let (#
1376 farInp,
1377 farExp
1378 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1379 GHC.Types.LT ->
1380 (#
1381 failInp,
1382 []
1383 #)
1384 GHC.Types.EQ ->
1385 (#
1386 farInp,
1387 farExp GHC.Base.<> []
1388 #)
1389 GHC.Types.GT ->
1390 (#
1391 farInp,
1392 farExp
1393 #)
1394 in readFail failInp farInp farExp
1395 in let readFail = catchHandler
1396 in let !(#
1397 c,
1398 cs
1399 #) = readNext cs
1400 in if Grammar.Nandlang.nandStringLetter c
1401 then
1402 name
1403 ( let _ = "suspend"
1404 in \farInp farExp v (!inp) ->
1405 let _ = "resume"
1406 in join
1407 farInp
1408 farExp
1409 ( let _ = "resume.genCode"
1410 in v
1411 )
1412 inp
1413 )
1414 cs
1415 Data.Map.Internal.Tip
1416 else
1417 let _ = "checkToken.else"
1418 in let (#
1419 farInp,
1420 farExp
1421 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
1422 GHC.Types.LT ->
1423 (#
1424 cs,
1425 [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "Char"]
1426 #)
1427 GHC.Types.EQ ->
1428 (#
1429 farInp,
1430 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "Char"]
1431 #)
1432 GHC.Types.GT ->
1433 (#
1434 farInp,
1435 farExp
1436 #)
1437 in catchHandler cs farInp farExp
1438 else
1439 let _ = "checkToken.else"
1440 in let (#
1441 farInp,
1442 farExp
1443 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1444 GHC.Types.LT ->
1445 (#
1446 failInp,
1447 [Symantic.Parser.Grammar.Combinators.ErrorItemToken '\'']
1448 #)
1449 GHC.Types.EQ ->
1450 (#
1451 farInp,
1452 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken '\'']
1453 #)
1454 GHC.Types.GT ->
1455 (#
1456 farInp,
1457 farExp
1458 #)
1459 in readFail failInp farInp farExp
1460 else
1461 let _ = "checkHorizon.else"
1462 in let (#
1463 farInp,
1464 farExp
1465 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1466 GHC.Types.LT ->
1467 (#
1468 failInp,
1469 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 4]
1470 #)
1471 GHC.Types.EQ ->
1472 (#
1473 farInp,
1474 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 4]
1475 #)
1476 GHC.Types.GT ->
1477 (#
1478 farInp,
1479 farExp
1480 #)
1481 in readFail failInp farInp farExp
1482 else
1483 let _ = "choicesBranch.else"
1484 in let (#
1485 farInp,
1486 farExp
1487 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1488 GHC.Types.LT ->
1489 (#
1490 failInp,
1491 []
1492 #)
1493 GHC.Types.EQ ->
1494 (#
1495 farInp,
1496 farExp GHC.Base.<> []
1497 #)
1498 GHC.Types.GT ->
1499 (#
1500 farInp,
1501 farExp
1502 #)
1503 in catchHandler failInp farInp farExp
1504 in let join = \farInp farExp v (!inp) ->
1505 name
1506 ( let _ = "suspend"
1507 in \farInp farExp v (!inp) ->
1508 let _ = "resume"
1509 in join
1510 farInp
1511 farExp
1512 ( let _ = "resume.genCode"
1513 in v
1514 )
1515 inp
1516 )
1517 inp
1518 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1519 in let _ = "catchException lbl=fail"
1520 in let catchHandler (!failInp) (!farInp) (!farExp) =
1521 let _ = "catchException.ko lbl=fail"
1522 in if ( \( Data.Text.Internal.Text
1523 _
1524 i
1525 _
1526 )
1527 ( Data.Text.Internal.Text
1528 _
1529 j
1530 _
1531 ) -> i GHC.Classes.== j
1532 )
1533 inp
1534 failInp
1535 then
1536 let _ = "choicesBranch.then"
1537 in let readFail = catchHandler
1538 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 failInp)
1539 then
1540 let !(#
1541 c,
1542 cs
1543 #) = readNext failInp
1544 in if ('1' GHC.Classes.==) c
1545 then
1546 let _ = "resume"
1547 in join
1548 farInp
1549 farExp
1550 ( let _ = "resume.genCode"
1551 in '1'
1552 )
1553 cs
1554 else
1555 let _ = "checkToken.else"
1556 in let (#
1557 farInp,
1558 farExp
1559 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1560 GHC.Types.LT ->
1561 (#
1562 failInp,
1563 [Symantic.Parser.Grammar.Combinators.ErrorItemToken '1']
1564 #)
1565 GHC.Types.EQ ->
1566 (#
1567 farInp,
1568 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken '1']
1569 #)
1570 GHC.Types.GT ->
1571 (#
1572 farInp,
1573 farExp
1574 #)
1575 in readFail failInp farInp farExp
1576 else
1577 let _ = "checkHorizon.else"
1578 in let (#
1579 farInp,
1580 farExp
1581 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1582 GHC.Types.LT ->
1583 (#
1584 failInp,
1585 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
1586 #)
1587 GHC.Types.EQ ->
1588 (#
1589 farInp,
1590 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
1591 #)
1592 GHC.Types.GT ->
1593 (#
1594 farInp,
1595 farExp
1596 #)
1597 in readFail failInp farInp farExp
1598 else
1599 let _ = "choicesBranch.else"
1600 in let (#
1601 farInp,
1602 farExp
1603 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1604 GHC.Types.LT ->
1605 (#
1606 failInp,
1607 []
1608 #)
1609 GHC.Types.EQ ->
1610 (#
1611 farInp,
1612 farExp GHC.Base.<> []
1613 #)
1614 GHC.Types.GT ->
1615 (#
1616 farInp,
1617 farExp
1618 #)
1619 in catchHandler failInp farInp farExp
1620 in let readFail = catchHandler
1621 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
1622 then
1623 let !(#
1624 c,
1625 cs
1626 #) = readNext inp
1627 in if ('0' GHC.Classes.==) c
1628 then
1629 let _ = "resume"
1630 in join init GHC.Types
1631 . []
1632 ( let _ = "resume.genCode"
1633 in '0'
1634 )
1635 cs
1636 else
1637 let _ = "checkToken.else"
1638 in let (#
1639 farInp,
1640 farExp
1641 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
1642 GHC.Types.LT ->
1643 (#
1644 inp,
1645 [Symantic.Parser.Grammar.Combinators.ErrorItemToken '0']
1646 #)
1647 GHC.Types.EQ ->
1648 (#
1649 init,
1650 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken '0']
1651 #)
1652 GHC.Types.GT ->
1653 (#
1654 init,
1655 GHC.Types . []
1656 #)
1657 in readFail inp farInp farExp
1658 else
1659 let _ = "checkHorizon.else"
1660 in let (#
1661 farInp,
1662 farExp
1663 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
1664 GHC.Types.LT ->
1665 (#
1666 inp,
1667 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
1668 #)
1669 GHC.Types.EQ ->
1670 (#
1671 init,
1672 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
1673 #)
1674 GHC.Types.GT ->
1675 (#
1676 init,
1677 GHC.Types . []
1678 #)
1679 in readFail inp farInp farExp
1680 name = \(!ok) (!inp) (!koByLabel) ->
1681 let _ = "catchException lbl=fail"
1682 in let catchHandler (!failInp) (!farInp) (!farExp) =
1683 let _ = "catchException.ko lbl=fail"
1684 in if ( \( Data.Text.Internal.Text
1685 _
1686 i
1687 _
1688 )
1689 ( Data.Text.Internal.Text
1690 _
1691 j
1692 _
1693 ) -> i GHC.Classes.== j
1694 )
1695 inp
1696 failInp
1697 then
1698 let _ = "choicesBranch.then"
1699 in let _ = "jump"
1700 in name ok failInp Data.Map.Internal.Tip
1701 else
1702 let _ = "choicesBranch.else"
1703 in let (#
1704 farInp,
1705 farExp
1706 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1707 GHC.Types.LT ->
1708 (#
1709 failInp,
1710 []
1711 #)
1712 GHC.Types.EQ ->
1713 (#
1714 farInp,
1715 farExp GHC.Base.<> []
1716 #)
1717 GHC.Types.GT ->
1718 (#
1719 farInp,
1720 farExp
1721 #)
1722 in finalRaise failInp farInp farExp
1723 in name
1724 ( let _ = "suspend"
1725 in \farInp farExp v (!inp) ->
1726 name
1727 ( let _ = "suspend"
1728 in \farInp farExp v (!inp) ->
1729 name
1730 ( let _ = "suspend"
1731 in \farInp farExp v (!inp) ->
1732 name
1733 ( let _ = "suspend"
1734 in \farInp farExp v (!inp) ->
1735 let _ = "resume"
1736 in ok
1737 farInp
1738 farExp
1739 ( let _ = "resume.genCode"
1740 in GHC.Tuple . ()
1741 )
1742 inp
1743 )
1744 inp
1745 Data.Map.Internal.Tip
1746 )
1747 inp
1748 Data.Map.Internal.Tip
1749 )
1750 inp
1751 Data.Map.Internal.Tip
1752 )
1753 inp
1754 Data.Map.Internal.Tip
1755 name = \(!ok) (!inp) (!koByLabel) ->
1756 let _ = "catchException lbl=fail"
1757 in let catchHandler (!failInp) (!farInp) (!farExp) =
1758 let _ = "catchException.ko lbl=fail"
1759 in if ( \( Data.Text.Internal.Text
1760 _
1761 i
1762 _
1763 )
1764 ( Data.Text.Internal.Text
1765 _
1766 j
1767 _
1768 ) -> i GHC.Classes.== j
1769 )
1770 inp
1771 failInp
1772 then
1773 let _ = "choicesBranch.then"
1774 in let _ = "resume"
1775 in ok
1776 farInp
1777 farExp
1778 ( let _ = "resume.genCode"
1779 in \x -> x
1780 )
1781 failInp
1782 else
1783 let _ = "choicesBranch.else"
1784 in let (#
1785 farInp,
1786 farExp
1787 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1788 GHC.Types.LT ->
1789 (#
1790 failInp,
1791 []
1792 #)
1793 GHC.Types.EQ ->
1794 (#
1795 farInp,
1796 farExp GHC.Base.<> []
1797 #)
1798 GHC.Types.GT ->
1799 (#
1800 farInp,
1801 farExp
1802 #)
1803 in finalRaise failInp farInp farExp
1804 in name
1805 ( let _ = "suspend"
1806 in \farInp farExp v (!inp) ->
1807 name
1808 ( let _ = "suspend"
1809 in \farInp farExp v (!inp) ->
1810 name
1811 ( let _ = "suspend"
1812 in \farInp farExp v (!inp) ->
1813 name
1814 ( let _ = "suspend"
1815 in \farInp farExp v (!inp) ->
1816 let _ = "resume"
1817 in ok
1818 farInp
1819 farExp
1820 ( let _ = "resume.genCode"
1821 in \x -> v v (v x)
1822 )
1823 inp
1824 )
1825 inp
1826 Data.Map.Internal.Tip
1827 )
1828 inp
1829 Data.Map.Internal.Tip
1830 )
1831 inp
1832 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1833 )
1834 inp
1835 Data.Map.Internal.Tip
1836 name = \(!ok) (!inp) (!koByLabel) ->
1837 let _ = "catchException lbl=fail"
1838 in let catchHandler (!failInp) (!farInp) (!farExp) =
1839 let _ = "catchException.ko lbl=fail"
1840 in if ( \( Data.Text.Internal.Text
1841 _
1842 i
1843 _
1844 )
1845 ( Data.Text.Internal.Text
1846 _
1847 j
1848 _
1849 ) -> i GHC.Classes.== j
1850 )
1851 inp
1852 failInp
1853 then
1854 let _ = "choicesBranch.then"
1855 in let _ = "resume"
1856 in ok
1857 farInp
1858 farExp
1859 ( let _ = "resume.genCode"
1860 in \x -> x
1861 )
1862 failInp
1863 else
1864 let _ = "choicesBranch.else"
1865 in let (#
1866 farInp,
1867 farExp
1868 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1869 GHC.Types.LT ->
1870 (#
1871 failInp,
1872 []
1873 #)
1874 GHC.Types.EQ ->
1875 (#
1876 farInp,
1877 farExp GHC.Base.<> []
1878 #)
1879 GHC.Types.GT ->
1880 (#
1881 farInp,
1882 farExp
1883 #)
1884 in finalRaise failInp farInp farExp
1885 in name
1886 ( let _ = "suspend"
1887 in \farInp farExp v (!inp) ->
1888 name
1889 ( let _ = "suspend"
1890 in \farInp farExp v (!inp) ->
1891 name
1892 ( let _ = "suspend"
1893 in \farInp farExp v (!inp) ->
1894 name
1895 ( let _ = "suspend"
1896 in \farInp farExp v (!inp) ->
1897 let _ = "resume"
1898 in ok
1899 farInp
1900 farExp
1901 ( let _ = "resume.genCode"
1902 in \x -> v v (v x)
1903 )
1904 inp
1905 )
1906 inp
1907 Data.Map.Internal.Tip
1908 )
1909 inp
1910 Data.Map.Internal.Tip
1911 )
1912 inp
1913 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1914 )
1915 inp
1916 Data.Map.Internal.Tip
1917 name = \(!ok) (!inp) (!koByLabel) ->
1918 let _ = "catchException lbl=fail"
1919 in let catchHandler (!failInp) (!farInp) (!farExp) =
1920 let _ = "catchException.ko lbl=fail"
1921 in if ( \( Data.Text.Internal.Text
1922 _
1923 i
1924 _
1925 )
1926 ( Data.Text.Internal.Text
1927 _
1928 j
1929 _
1930 ) -> i GHC.Classes.== j
1931 )
1932 inp
1933 failInp
1934 then
1935 let _ = "choicesBranch.then"
1936 in let _ = "resume"
1937 in ok
1938 farInp
1939 farExp
1940 ( let _ = "resume.genCode"
1941 in \x -> x
1942 )
1943 failInp
1944 else
1945 let _ = "choicesBranch.else"
1946 in let (#
1947 farInp,
1948 farExp
1949 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
1950 GHC.Types.LT ->
1951 (#
1952 failInp,
1953 []
1954 #)
1955 GHC.Types.EQ ->
1956 (#
1957 farInp,
1958 farExp GHC.Base.<> []
1959 #)
1960 GHC.Types.GT ->
1961 (#
1962 farInp,
1963 farExp
1964 #)
1965 in finalRaise failInp farInp farExp
1966 in name
1967 ( let _ = "suspend"
1968 in \farInp farExp v (!inp) ->
1969 name
1970 ( let _ = "suspend"
1971 in \farInp farExp v (!inp) ->
1972 name
1973 ( let _ = "suspend"
1974 in \farInp farExp v (!inp) ->
1975 name
1976 ( let _ = "suspend"
1977 in \farInp farExp v (!inp) ->
1978 let _ = "resume"
1979 in ok
1980 farInp
1981 farExp
1982 ( let _ = "resume.genCode"
1983 in \x -> v v (v x)
1984 )
1985 inp
1986 )
1987 inp
1988 Data.Map.Internal.Tip
1989 )
1990 inp
1991 Data.Map.Internal.Tip
1992 )
1993 inp
1994 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
1995 )
1996 inp
1997 Data.Map.Internal.Tip
1998 name = \(!ok) (!inp) (!koByLabel) ->
1999 let _ = "catchException lbl=fail"
2000 in let catchHandler (!failInp) (!farInp) (!farExp) =
2001 let _ = "catchException.ko lbl=fail"
2002 in if ( \( Data.Text.Internal.Text
2003 _
2004 i
2005 _
2006 )
2007 ( Data.Text.Internal.Text
2008 _
2009 j
2010 _
2011 ) -> i GHC.Classes.== j
2012 )
2013 inp
2014 failInp
2015 then
2016 let _ = "choicesBranch.then"
2017 in let _ = "resume"
2018 in ok
2019 farInp
2020 farExp
2021 ( let _ = "resume.genCode"
2022 in \x -> x
2023 )
2024 failInp
2025 else
2026 let _ = "choicesBranch.else"
2027 in let (#
2028 farInp,
2029 farExp
2030 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2031 GHC.Types.LT ->
2032 (#
2033 failInp,
2034 []
2035 #)
2036 GHC.Types.EQ ->
2037 (#
2038 farInp,
2039 farExp GHC.Base.<> []
2040 #)
2041 GHC.Types.GT ->
2042 (#
2043 farInp,
2044 farExp
2045 #)
2046 in finalRaise failInp farInp farExp
2047 in name
2048 ( let _ = "suspend"
2049 in \farInp farExp v (!inp) ->
2050 name
2051 ( let _ = "suspend"
2052 in \farInp farExp v (!inp) ->
2053 name
2054 ( let _ = "suspend"
2055 in \farInp farExp v (!inp) ->
2056 name
2057 ( let _ = "suspend"
2058 in \farInp farExp v (!inp) ->
2059 let _ = "resume"
2060 in ok
2061 farInp
2062 farExp
2063 ( let _ = "resume.genCode"
2064 in \x -> v v (v x)
2065 )
2066 inp
2067 )
2068 inp
2069 Data.Map.Internal.Tip
2070 )
2071 inp
2072 Data.Map.Internal.Tip
2073 )
2074 inp
2075 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2076 )
2077 inp
2078 Data.Map.Internal.Tip
2079 name = \(!ok) (!inp) (!koByLabel) ->
2080 let _ = "catchException lbl=fail"
2081 in let catchHandler (!failInp) (!farInp) (!farExp) =
2082 let _ = "catchException.ko lbl=fail"
2083 in if ( \( Data.Text.Internal.Text
2084 _
2085 i
2086 _
2087 )
2088 ( Data.Text.Internal.Text
2089 _
2090 j
2091 _
2092 ) -> i GHC.Classes.== j
2093 )
2094 inp
2095 failInp
2096 then
2097 let _ = "choicesBranch.then"
2098 in let _ = "resume"
2099 in ok
2100 farInp
2101 farExp
2102 ( let _ = "resume.genCode"
2103 in \x -> x
2104 )
2105 failInp
2106 else
2107 let _ = "choicesBranch.else"
2108 in let (#
2109 farInp,
2110 farExp
2111 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2112 GHC.Types.LT ->
2113 (#
2114 failInp,
2115 []
2116 #)
2117 GHC.Types.EQ ->
2118 (#
2119 farInp,
2120 farExp GHC.Base.<> []
2121 #)
2122 GHC.Types.GT ->
2123 (#
2124 farInp,
2125 farExp
2126 #)
2127 in finalRaise failInp farInp farExp
2128 in name
2129 ( let _ = "suspend"
2130 in \farInp farExp v (!inp) ->
2131 name
2132 ( let _ = "suspend"
2133 in \farInp farExp v (!inp) ->
2134 let _ = "resume"
2135 in ok
2136 farInp
2137 farExp
2138 ( let _ = "resume.genCode"
2139 in \x -> v x
2140 )
2141 inp
2142 )
2143 inp
2144 Data.Map.Internal.Tip
2145 )
2146 inp
2147 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2148 name = \(!ok) (!inp) (!koByLabel) ->
2149 let _ = "catchException lbl=fail"
2150 in let catchHandler (!failInp) (!farInp) (!farExp) =
2151 let _ = "catchException.ko lbl=fail"
2152 in if ( \( Data.Text.Internal.Text
2153 _
2154 i
2155 _
2156 )
2157 ( Data.Text.Internal.Text
2158 _
2159 j
2160 _
2161 ) -> i GHC.Classes.== j
2162 )
2163 inp
2164 failInp
2165 then
2166 let _ = "choicesBranch.then"
2167 in let _ = "resume"
2168 in ok
2169 farInp
2170 farExp
2171 ( let _ = "resume.genCode"
2172 in \x -> x
2173 )
2174 failInp
2175 else
2176 let _ = "choicesBranch.else"
2177 in let (#
2178 farInp,
2179 farExp
2180 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2181 GHC.Types.LT ->
2182 (#
2183 failInp,
2184 []
2185 #)
2186 GHC.Types.EQ ->
2187 (#
2188 farInp,
2189 farExp GHC.Base.<> []
2190 #)
2191 GHC.Types.GT ->
2192 (#
2193 farInp,
2194 farExp
2195 #)
2196 in finalRaise failInp farInp farExp
2197 in name
2198 ( let _ = "suspend"
2199 in \farInp farExp v (!inp) ->
2200 name
2201 ( let _ = "suspend"
2202 in \farInp farExp v (!inp) ->
2203 let _ = "resume"
2204 in ok
2205 farInp
2206 farExp
2207 ( let _ = "resume.genCode"
2208 in \x -> v x
2209 )
2210 inp
2211 )
2212 inp
2213 Data.Map.Internal.Tip
2214 )
2215 inp
2216 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2217 name = \(!ok) (!inp) (!koByLabel) ->
2218 let _ = "catchException lbl=fail"
2219 in let catchHandler (!failInp) (!farInp) (!farExp) =
2220 let _ = "catchException.ko lbl=fail"
2221 in if ( \( Data.Text.Internal.Text
2222 _
2223 i
2224 _
2225 )
2226 ( Data.Text.Internal.Text
2227 _
2228 j
2229 _
2230 ) -> i GHC.Classes.== j
2231 )
2232 inp
2233 failInp
2234 then
2235 let _ = "choicesBranch.then"
2236 in let _ = "resume"
2237 in ok
2238 farInp
2239 farExp
2240 ( let _ = "resume.genCode"
2241 in \x -> x
2242 )
2243 failInp
2244 else
2245 let _ = "choicesBranch.else"
2246 in let (#
2247 farInp,
2248 farExp
2249 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2250 GHC.Types.LT ->
2251 (#
2252 failInp,
2253 []
2254 #)
2255 GHC.Types.EQ ->
2256 (#
2257 farInp,
2258 farExp GHC.Base.<> []
2259 #)
2260 GHC.Types.GT ->
2261 (#
2262 farInp,
2263 farExp
2264 #)
2265 in finalRaise failInp farInp farExp
2266 in let join = \farInp farExp v (!inp) ->
2267 name
2268 ( let _ = "suspend"
2269 in \farInp farExp v (!inp) ->
2270 let _ = "resume"
2271 in ok
2272 farInp
2273 farExp
2274 ( let _ = "resume.genCode"
2275 in \x -> v x
2276 )
2277 inp
2278 )
2279 inp
2280 Data.Map.Internal.Tip
2281 in let _ = "catchException lbl=fail"
2282 in let catchHandler (!failInp) (!farInp) (!farExp) =
2283 let _ = "catchException.ko lbl=fail"
2284 in if ( \( Data.Text.Internal.Text
2285 _
2286 i
2287 _
2288 )
2289 ( Data.Text.Internal.Text
2290 _
2291 j
2292 _
2293 ) -> i GHC.Classes.== j
2294 )
2295 inp
2296 failInp
2297 then
2298 let _ = "choicesBranch.then"
2299 in name
2300 ( let _ = "suspend"
2301 in \farInp farExp v (!inp) ->
2302 name
2303 ( let _ = "suspend"
2304 in \farInp farExp v (!inp) ->
2305 let _ = "resume"
2306 in join
2307 farInp
2308 farExp
2309 ( let _ = "resume.genCode"
2310 in v
2311 )
2312 inp
2313 )
2314 inp
2315 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2316 )
2317 failInp
2318 Data.Map.Internal.Tip
2319 else
2320 let _ = "choicesBranch.else"
2321 in let (#
2322 farInp,
2323 farExp
2324 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2325 GHC.Types.LT ->
2326 (#
2327 failInp,
2328 []
2329 #)
2330 GHC.Types.EQ ->
2331 (#
2332 farInp,
2333 farExp GHC.Base.<> []
2334 #)
2335 GHC.Types.GT ->
2336 (#
2337 farInp,
2338 farExp
2339 #)
2340 in catchHandler failInp farInp farExp
2341 in let join = \farInp farExp v (!inp) ->
2342 let _ = "resume"
2343 in join
2344 farInp
2345 farExp
2346 ( let _ = "resume.genCode"
2347 in v
2348 )
2349 inp
2350 in let _ = "catchException lbl=fail"
2351 in let catchHandler (!failInp) (!farInp) (!farExp) =
2352 let _ = "catchException.ko lbl=fail"
2353 in if ( \( Data.Text.Internal.Text
2354 _
2355 i
2356 _
2357 )
2358 ( Data.Text.Internal.Text
2359 _
2360 j
2361 _
2362 ) -> i GHC.Classes.== j
2363 )
2364 inp
2365 failInp
2366 then
2367 let _ = "choicesBranch.then"
2368 in let _ = "catchException lbl=fail"
2369 in let catchHandler (!failInp) (!farInp) (!farExp) =
2370 let _ = "catchException.ko lbl=fail"
2371 in let (#
2372 farInp,
2373 farExp
2374 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2375 GHC.Types.LT ->
2376 (#
2377 failInp,
2378 []
2379 #)
2380 GHC.Types.EQ ->
2381 (#
2382 farInp,
2383 farExp GHC.Base.<> []
2384 #)
2385 GHC.Types.GT ->
2386 (#
2387 farInp,
2388 farExp
2389 #)
2390 in catchHandler failInp farInp farExp
2391 in let join = \farInp farExp v (!inp) ->
2392 name
2393 ( let _ = "suspend"
2394 in \farInp farExp v (!inp) ->
2395 name
2396 ( let _ = "suspend"
2397 in \farInp farExp v (!inp) ->
2398 name
2399 ( let _ = "suspend"
2400 in \farInp farExp v (!inp) ->
2401 name
2402 ( let _ = "suspend"
2403 in \farInp farExp v (!inp) ->
2404 let readFail = catchHandler
2405 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)
2406 then
2407 let !(#
2408 c,
2409 cs
2410 #) = readNext inp
2411 in if ('=' GHC.Classes.==) c
2412 then
2413 name
2414 ( let _ = "suspend"
2415 in \farInp farExp v (!inp) ->
2416 name
2417 ( let _ = "suspend"
2418 in \farInp farExp v (!inp) ->
2419 name
2420 ( let _ = "suspend"
2421 in \farInp farExp v (!inp) ->
2422 name
2423 ( let _ = "suspend"
2424 in \farInp farExp v (!inp) ->
2425 name
2426 ( let _ = "suspend"
2427 in \farInp farExp v (!inp) ->
2428 name
2429 ( let _ = "suspend"
2430 in \farInp farExp v (!inp) ->
2431 let _ = "resume"
2432 in join
2433 farInp
2434 farExp
2435 ( let _ = "resume.genCode"
2436 in v
2437 )
2438 inp
2439 )
2440 inp
2441 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
2442 )
2443 inp
2444 Data.Map.Internal.Tip
2445 )
2446 inp
2447 Data.Map.Internal.Tip
2448 )
2449 inp
2450 Data.Map.Internal.Tip
2451 )
2452 inp
2453 Data.Map.Internal.Tip
2454 )
2455 cs
2456 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
2457 else
2458 let _ = "checkToken.else"
2459 in let (#
2460 farInp,
2461 farExp
2462 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
2463 GHC.Types.LT ->
2464 (#
2465 inp,
2466 [Symantic.Parser.Grammar.Combinators.ErrorItemToken '=']
2467 #)
2468 GHC.Types.EQ ->
2469 (#
2470 farInp,
2471 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken '=']
2472 #)
2473 GHC.Types.GT ->
2474 (#
2475 farInp,
2476 farExp
2477 #)
2478 in readFail inp farInp farExp
2479 else
2480 let _ = "checkHorizon.else"
2481 in let (#
2482 farInp,
2483 farExp
2484 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
2485 GHC.Types.LT ->
2486 (#
2487 inp,
2488 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 4]
2489 #)
2490 GHC.Types.EQ ->
2491 (#
2492 farInp,
2493 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 4]
2494 #)
2495 GHC.Types.GT ->
2496 (#
2497 farInp,
2498 farExp
2499 #)
2500 in readFail inp farInp farExp
2501 )
2502 inp
2503 Data.Map.Internal.Tip
2504 )
2505 inp
2506 Data.Map.Internal.Tip
2507 )
2508 inp
2509 Data.Map.Internal.Tip
2510 )
2511 inp
2512 Data.Map.Internal.Tip
2513 in let _ = "catchException lbl=fail"
2514 in let catchHandler (!failInp) (!farInp) (!farExp) =
2515 let _ = "catchException.ko lbl=fail"
2516 in if ( \( Data.Text.Internal.Text
2517 _
2518 i
2519 _
2520 )
2521 ( Data.Text.Internal.Text
2522 _
2523 j
2524 _
2525 ) -> i GHC.Classes.== j
2526 )
2527 failInp
2528 failInp
2529 then
2530 let _ = "choicesBranch.then"
2531 in name
2532 ( let _ = "suspend"
2533 in \farInp farExp v (!inp) ->
2534 let _ = "resume"
2535 in join
2536 farInp
2537 farExp
2538 ( let _ = "resume.genCode"
2539 in v
2540 )
2541 inp
2542 )
2543 failInp
2544 Data.Map.Internal.Tip
2545 else
2546 let _ = "choicesBranch.else"
2547 in let (#
2548 farInp,
2549 farExp
2550 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2551 GHC.Types.LT ->
2552 (#
2553 failInp,
2554 []
2555 #)
2556 GHC.Types.EQ ->
2557 (#
2558 farInp,
2559 farExp GHC.Base.<> []
2560 #)
2561 GHC.Types.GT ->
2562 (#
2563 farInp,
2564 farExp
2565 #)
2566 in catchHandler failInp farInp farExp
2567 in let _ = "catchException lbl=fail"
2568 in let catchHandler (!failInp) (!farInp) (!farExp) =
2569 let _ = "catchException.ko lbl=fail"
2570 in let (#
2571 farInp,
2572 farExp
2573 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2574 GHC.Types.LT ->
2575 (#
2576 failInp,
2577 []
2578 #)
2579 GHC.Types.EQ ->
2580 (#
2581 farInp,
2582 farExp GHC.Base.<> []
2583 #)
2584 GHC.Types.GT ->
2585 (#
2586 farInp,
2587 farExp
2588 #)
2589 in catchHandler failInp farInp farExp
2590 in let readFail = catchHandler
2591 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 10 failInp)
2592 then
2593 let !(#
2594 c,
2595 cs
2596 #) = readNext failInp
2597 in if ('v' GHC.Classes.==) c
2598 then
2599 let readFail = readFail
2600 in let !(#
2601 c,
2602 cs
2603 #) = readNext cs
2604 in if ('a' GHC.Classes.==) c
2605 then
2606 let readFail = readFail
2607 in let !(#
2608 c,
2609 cs
2610 #) = readNext cs
2611 in if ('r' GHC.Classes.==) c
2612 then
2613 name
2614 ( let _ = "suspend"
2615 in \farInp farExp v (!inp) ->
2616 let _ = "resume"
2617 in join
2618 farInp
2619 farExp
2620 ( let _ = "resume.genCode"
2621 in GHC.Tuple . ()
2622 )
2623 inp
2624 )
2625 cs
2626 Data.Map.Internal.Tip
2627 else
2628 let _ = "checkToken.else"
2629 in let (#
2630 farInp,
2631 farExp
2632 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2633 GHC.Types.LT ->
2634 (#
2635 cs,
2636 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'r']
2637 #)
2638 GHC.Types.EQ ->
2639 (#
2640 farInp,
2641 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'r']
2642 #)
2643 GHC.Types.GT ->
2644 (#
2645 farInp,
2646 farExp
2647 #)
2648 in readFail cs farInp farExp
2649 else
2650 let _ = "checkToken.else"
2651 in let (#
2652 farInp,
2653 farExp
2654 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2655 GHC.Types.LT ->
2656 (#
2657 cs,
2658 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'a']
2659 #)
2660 GHC.Types.EQ ->
2661 (#
2662 farInp,
2663 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'a']
2664 #)
2665 GHC.Types.GT ->
2666 (#
2667 farInp,
2668 farExp
2669 #)
2670 in readFail cs farInp farExp
2671 else
2672 let _ = "checkToken.else"
2673 in let (#
2674 farInp,
2675 farExp
2676 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2677 GHC.Types.LT ->
2678 (#
2679 failInp,
2680 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'v']
2681 #)
2682 GHC.Types.EQ ->
2683 (#
2684 farInp,
2685 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'v']
2686 #)
2687 GHC.Types.GT ->
2688 (#
2689 farInp,
2690 farExp
2691 #)
2692 in readFail failInp farInp farExp
2693 else
2694 let _ = "checkHorizon.else"
2695 in let (#
2696 farInp,
2697 farExp
2698 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2699 GHC.Types.LT ->
2700 (#
2701 failInp,
2702 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 11]
2703 #)
2704 GHC.Types.EQ ->
2705 (#
2706 farInp,
2707 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 11]
2708 #)
2709 GHC.Types.GT ->
2710 (#
2711 farInp,
2712 farExp
2713 #)
2714 in readFail failInp farInp farExp
2715 else
2716 let _ = "choicesBranch.else"
2717 in let (#
2718 farInp,
2719 farExp
2720 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2721 GHC.Types.LT ->
2722 (#
2723 failInp,
2724 []
2725 #)
2726 GHC.Types.EQ ->
2727 (#
2728 farInp,
2729 farExp GHC.Base.<> []
2730 #)
2731 GHC.Types.GT ->
2732 (#
2733 farInp,
2734 farExp
2735 #)
2736 in catchHandler failInp farInp farExp
2737 in let join = \farInp farExp v (!inp) ->
2738 let _ = "resume"
2739 in join
2740 farInp
2741 farExp
2742 ( let _ = "resume.genCode"
2743 in v
2744 )
2745 inp
2746 in let _ = "catchException lbl=fail"
2747 in let catchHandler (!failInp) (!farInp) (!farExp) =
2748 let _ = "catchException.ko lbl=fail"
2749 in if ( \( Data.Text.Internal.Text
2750 _
2751 i
2752 _
2753 )
2754 ( Data.Text.Internal.Text
2755 _
2756 j
2757 _
2758 ) -> i GHC.Classes.== j
2759 )
2760 inp
2761 failInp
2762 then
2763 let _ = "choicesBranch.then"
2764 in let _ = "catchException lbl=fail"
2765 in let catchHandler (!failInp) (!farInp) (!farExp) =
2766 let _ = "catchException.ko lbl=fail"
2767 in let (#
2768 farInp,
2769 farExp
2770 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2771 GHC.Types.LT ->
2772 (#
2773 failInp,
2774 []
2775 #)
2776 GHC.Types.EQ ->
2777 (#
2778 farInp,
2779 farExp GHC.Base.<> []
2780 #)
2781 GHC.Types.GT ->
2782 (#
2783 farInp,
2784 farExp
2785 #)
2786 in catchHandler failInp farInp farExp
2787 in let readFail = catchHandler
2788 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 10 failInp)
2789 then
2790 let !(#
2791 c,
2792 cs
2793 #) = readNext failInp
2794 in if ('w' GHC.Classes.==) c
2795 then
2796 let readFail = readFail
2797 in let !(#
2798 c,
2799 cs
2800 #) = readNext cs
2801 in if ('h' GHC.Classes.==) c
2802 then
2803 let readFail = readFail
2804 in let !(#
2805 c,
2806 cs
2807 #) = readNext cs
2808 in if ('i' GHC.Classes.==) c
2809 then
2810 let readFail = readFail
2811 in let !(#
2812 c,
2813 cs
2814 #) = readNext cs
2815 in if ('l' GHC.Classes.==) c
2816 then
2817 let readFail = readFail
2818 in let !(#
2819 c,
2820 cs
2821 #) = readNext cs
2822 in if ('e' GHC.Classes.==) c
2823 then
2824 name
2825 ( let _ = "suspend"
2826 in \farInp farExp v (!inp) ->
2827 name
2828 ( let _ = "suspend"
2829 in \farInp farExp v (!inp) ->
2830 name
2831 ( let _ = "suspend"
2832 in \farInp farExp v (!inp) ->
2833 let _ = "resume"
2834 in join
2835 farInp
2836 farExp
2837 ( let _ = "resume.genCode"
2838 in v
2839 )
2840 inp
2841 )
2842 inp
2843 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
2844 )
2845 inp
2846 Data.Map.Internal.Tip
2847 )
2848 cs
2849 Data.Map.Internal.Tip
2850 else
2851 let _ = "checkToken.else"
2852 in let (#
2853 farInp,
2854 farExp
2855 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2856 GHC.Types.LT ->
2857 (#
2858 cs,
2859 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'e']
2860 #)
2861 GHC.Types.EQ ->
2862 (#
2863 farInp,
2864 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'e']
2865 #)
2866 GHC.Types.GT ->
2867 (#
2868 farInp,
2869 farExp
2870 #)
2871 in readFail cs farInp farExp
2872 else
2873 let _ = "checkToken.else"
2874 in let (#
2875 farInp,
2876 farExp
2877 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2878 GHC.Types.LT ->
2879 (#
2880 cs,
2881 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'l']
2882 #)
2883 GHC.Types.EQ ->
2884 (#
2885 farInp,
2886 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'l']
2887 #)
2888 GHC.Types.GT ->
2889 (#
2890 farInp,
2891 farExp
2892 #)
2893 in readFail cs farInp farExp
2894 else
2895 let _ = "checkToken.else"
2896 in let (#
2897 farInp,
2898 farExp
2899 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2900 GHC.Types.LT ->
2901 (#
2902 cs,
2903 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'i']
2904 #)
2905 GHC.Types.EQ ->
2906 (#
2907 farInp,
2908 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'i']
2909 #)
2910 GHC.Types.GT ->
2911 (#
2912 farInp,
2913 farExp
2914 #)
2915 in readFail cs farInp farExp
2916 else
2917 let _ = "checkToken.else"
2918 in let (#
2919 farInp,
2920 farExp
2921 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
2922 GHC.Types.LT ->
2923 (#
2924 cs,
2925 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'h']
2926 #)
2927 GHC.Types.EQ ->
2928 (#
2929 farInp,
2930 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'h']
2931 #)
2932 GHC.Types.GT ->
2933 (#
2934 farInp,
2935 farExp
2936 #)
2937 in readFail cs farInp farExp
2938 else
2939 let _ = "checkToken.else"
2940 in let (#
2941 farInp,
2942 farExp
2943 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2944 GHC.Types.LT ->
2945 (#
2946 failInp,
2947 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'w']
2948 #)
2949 GHC.Types.EQ ->
2950 (#
2951 farInp,
2952 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'w']
2953 #)
2954 GHC.Types.GT ->
2955 (#
2956 farInp,
2957 farExp
2958 #)
2959 in readFail failInp farInp farExp
2960 else
2961 let _ = "checkHorizon.else"
2962 in let (#
2963 farInp,
2964 farExp
2965 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2966 GHC.Types.LT ->
2967 (#
2968 failInp,
2969 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 11]
2970 #)
2971 GHC.Types.EQ ->
2972 (#
2973 farInp,
2974 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 11]
2975 #)
2976 GHC.Types.GT ->
2977 (#
2978 farInp,
2979 farExp
2980 #)
2981 in readFail failInp farInp farExp
2982 else
2983 let _ = "choicesBranch.else"
2984 in let (#
2985 farInp,
2986 farExp
2987 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
2988 GHC.Types.LT ->
2989 (#
2990 failInp,
2991 []
2992 #)
2993 GHC.Types.EQ ->
2994 (#
2995 farInp,
2996 farExp GHC.Base.<> []
2997 #)
2998 GHC.Types.GT ->
2999 (#
3000 farInp,
3001 farExp
3002 #)
3003 in catchHandler failInp farInp farExp
3004 in let _ = "catchException lbl=fail"
3005 in let catchHandler (!failInp) (!farInp) (!farExp) =
3006 let _ = "catchException.ko lbl=fail"
3007 in let (#
3008 farInp,
3009 farExp
3010 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
3011 GHC.Types.LT ->
3012 (#
3013 inp,
3014 []
3015 #)
3016 GHC.Types.EQ ->
3017 (#
3018 farInp,
3019 farExp GHC.Base.<> []
3020 #)
3021 GHC.Types.GT ->
3022 (#
3023 farInp,
3024 farExp
3025 #)
3026 in catchHandler inp farInp farExp
3027 in let readFail = catchHandler
3028 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
3029 then
3030 let !(#
3031 c,
3032 cs
3033 #) = readNext inp
3034 in if ('i' GHC.Classes.==) c
3035 then
3036 let readFail = readFail
3037 in let !(#
3038 c,
3039 cs
3040 #) = readNext cs
3041 in if ('f' GHC.Classes.==) c
3042 then
3043 name
3044 ( let _ = "suspend"
3045 in \farInp farExp v (!inp) ->
3046 let _ = "resume"
3047 in join
3048 farInp
3049 farExp
3050 ( let _ = "resume.genCode"
3051 in v
3052 )
3053 inp
3054 )
3055 cs
3056 Data.Map.Internal.Tip
3057 else
3058 let _ = "checkToken.else"
3059 in let (#
3060 farInp,
3061 farExp
3062 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3063 GHC.Types.LT ->
3064 (#
3065 cs,
3066 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'f']
3067 #)
3068 GHC.Types.EQ ->
3069 (#
3070 init,
3071 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'f']
3072 #)
3073 GHC.Types.GT ->
3074 (#
3075 init,
3076 GHC.Types . []
3077 #)
3078 in readFail cs farInp farExp
3079 else
3080 let _ = "checkToken.else"
3081 in let (#
3082 farInp,
3083 farExp
3084 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3085 GHC.Types.LT ->
3086 (#
3087 inp,
3088 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'i']
3089 #)
3090 GHC.Types.EQ ->
3091 (#
3092 init,
3093 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'i']
3094 #)
3095 GHC.Types.GT ->
3096 (#
3097 init,
3098 GHC.Types . []
3099 #)
3100 in readFail inp farInp farExp
3101 else
3102 let _ = "checkHorizon.else"
3103 in let (#
3104 farInp,
3105 farExp
3106 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3107 GHC.Types.LT ->
3108 (#
3109 inp,
3110 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
3111 #)
3112 GHC.Types.EQ ->
3113 (#
3114 init,
3115 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
3116 #)
3117 GHC.Types.GT ->
3118 (#
3119 init,
3120 GHC.Types . []
3121 #)
3122 in readFail inp farInp farExp
3123 name = \(!ok) (!inp) (!koByLabel) ->
3124 let _ = "catchException lbl=fail"
3125 in let catchHandler (!failInp) (!farInp) (!farExp) =
3126 let _ = "catchException.ko lbl=fail"
3127 in if ( \( Data.Text.Internal.Text
3128 _
3129 i
3130 _
3131 )
3132 ( Data.Text.Internal.Text
3133 _
3134 j
3135 _
3136 ) -> i GHC.Classes.== j
3137 )
3138 inp
3139 failInp
3140 then
3141 let _ = "choicesBranch.then"
3142 in let _ = "resume"
3143 in ok
3144 farInp
3145 farExp
3146 ( let _ = "resume.genCode"
3147 in \x -> x
3148 )
3149 failInp
3150 else
3151 let _ = "choicesBranch.else"
3152 in let (#
3153 farInp,
3154 farExp
3155 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
3156 GHC.Types.LT ->
3157 (#
3158 failInp,
3159 []
3160 #)
3161 GHC.Types.EQ ->
3162 (#
3163 farInp,
3164 farExp GHC.Base.<> []
3165 #)
3166 GHC.Types.GT ->
3167 (#
3168 farInp,
3169 farExp
3170 #)
3171 in finalRaise failInp farInp farExp
3172 in let readFail = catchHandler
3173 in if readMore inp
3174 then
3175 let !(#
3176 c,
3177 cs
3178 #) = readNext inp
3179 in if Grammar.Nandlang.nandIdentLetter c
3180 then
3181 name
3182 ( let _ = "suspend"
3183 in \farInp farExp v (!inp) ->
3184 let _ = "resume"
3185 in ok
3186 farInp
3187 farExp
3188 ( let _ = "resume.genCode"
3189 in \x -> v x
3190 )
3191 inp
3192 )
3193 cs
3194 Data.Map.Internal.Tip
3195 else
3196 let _ = "checkToken.else"
3197 in let (#
3198 farInp,
3199 farExp
3200 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3201 GHC.Types.LT ->
3202 (#
3203 inp,
3204 [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "identLetter"]
3205 #)
3206 GHC.Types.EQ ->
3207 (#
3208 init,
3209 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "identLetter"]
3210 #)
3211 GHC.Types.GT ->
3212 (#
3213 init,
3214 GHC.Types . []
3215 #)
3216 in readFail inp farInp farExp
3217 else
3218 let _ = "checkHorizon.else"
3219 in let (#
3220 farInp,
3221 farExp
3222 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3223 GHC.Types.LT ->
3224 (#
3225 inp,
3226 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
3227 #)
3228 GHC.Types.EQ ->
3229 (#
3230 init,
3231 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
3232 #)
3233 GHC.Types.GT ->
3234 (#
3235 init,
3236 GHC.Types . []
3237 #)
3238 in readFail inp farInp farExp
3239 name = \(!ok) (!inp) (!koByLabel) ->
3240 let _ = "catchException lbl=fail"
3241 in let catchHandler (!failInp) (!farInp) (!farExp) =
3242 let _ = "catchException.ko lbl=fail"
3243 in if ( \( Data.Text.Internal.Text
3244 _
3245 i
3246 _
3247 )
3248 ( Data.Text.Internal.Text
3249 _
3250 j
3251 _
3252 ) -> i GHC.Classes.== j
3253 )
3254 inp
3255 failInp
3256 then
3257 let _ = "choicesBranch.then"
3258 in let _ = "resume"
3259 in ok
3260 farInp
3261 farExp
3262 ( let _ = "resume.genCode"
3263 in \x -> x
3264 )
3265 failInp
3266 else
3267 let _ = "choicesBranch.else"
3268 in let (#
3269 farInp,
3270 farExp
3271 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
3272 GHC.Types.LT ->
3273 (#
3274 failInp,
3275 []
3276 #)
3277 GHC.Types.EQ ->
3278 (#
3279 farInp,
3280 farExp GHC.Base.<> []
3281 #)
3282 GHC.Types.GT ->
3283 (#
3284 farInp,
3285 farExp
3286 #)
3287 in finalRaise failInp farInp farExp
3288 in let readFail = catchHandler
3289 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)
3290 then
3291 let !(#
3292 c,
3293 cs
3294 #) = readNext inp
3295 in if ('!' GHC.Classes.==) c
3296 then
3297 name
3298 ( let _ = "suspend"
3299 in \farInp farExp v (!inp) ->
3300 name
3301 ( let _ = "suspend"
3302 in \farInp farExp v (!inp) ->
3303 name
3304 ( let _ = "suspend"
3305 in \farInp farExp v (!inp) ->
3306 let _ = "resume"
3307 in ok
3308 farInp
3309 farExp
3310 ( let _ = "resume.genCode"
3311 in \x -> v x
3312 )
3313 inp
3314 )
3315 inp
3316 Data.Map.Internal.Tip
3317 )
3318 inp
3319 Data.Map.Internal.Tip
3320 )
3321 cs
3322 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
3323 else
3324 let _ = "checkToken.else"
3325 in let (#
3326 farInp,
3327 farExp
3328 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3329 GHC.Types.LT ->
3330 (#
3331 inp,
3332 [Symantic.Parser.Grammar.Combinators.ErrorItemToken '!']
3333 #)
3334 GHC.Types.EQ ->
3335 (#
3336 init,
3337 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken '!']
3338 #)
3339 GHC.Types.GT ->
3340 (#
3341 init,
3342 GHC.Types . []
3343 #)
3344 in readFail inp farInp farExp
3345 else
3346 let _ = "checkHorizon.else"
3347 in let (#
3348 farInp,
3349 farExp
3350 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3351 GHC.Types.LT ->
3352 (#
3353 inp,
3354 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 4]
3355 #)
3356 GHC.Types.EQ ->
3357 (#
3358 init,
3359 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 4]
3360 #)
3361 GHC.Types.GT ->
3362 (#
3363 init,
3364 GHC.Types . []
3365 #)
3366 in readFail inp farInp farExp
3367 name = \(!ok) (!inp) (!koByLabel) ->
3368 let _ = "catchException lbl=fail"
3369 in let catchHandler (!failInp) (!farInp) (!farExp) =
3370 let _ = "catchException.ko lbl=fail"
3371 in if ( \( Data.Text.Internal.Text
3372 _
3373 i
3374 _
3375 )
3376 ( Data.Text.Internal.Text
3377 _
3378 j
3379 _
3380 ) -> i GHC.Classes.== j
3381 )
3382 inp
3383 failInp
3384 then
3385 let _ = "choicesBranch.then"
3386 in let _ = "resume"
3387 in ok
3388 farInp
3389 farExp
3390 ( let _ = "resume.genCode"
3391 in \x -> x
3392 )
3393 failInp
3394 else
3395 let _ = "choicesBranch.else"
3396 in let (#
3397 farInp,
3398 farExp
3399 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
3400 GHC.Types.LT ->
3401 (#
3402 failInp,
3403 []
3404 #)
3405 GHC.Types.EQ ->
3406 (#
3407 farInp,
3408 farExp GHC.Base.<> []
3409 #)
3410 GHC.Types.GT ->
3411 (#
3412 farInp,
3413 farExp
3414 #)
3415 in finalRaise failInp farInp farExp
3416 in let _ = "catchException lbl=fail"
3417 in let catchHandler (!failInp) (!farInp) (!farExp) =
3418 let _ = "catchException.ko lbl=fail"
3419 in let (#
3420 farInp,
3421 farExp
3422 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
3423 GHC.Types.LT ->
3424 (#
3425 inp,
3426 []
3427 #)
3428 GHC.Types.EQ ->
3429 (#
3430 farInp,
3431 farExp GHC.Base.<> []
3432 #)
3433 GHC.Types.GT ->
3434 (#
3435 farInp,
3436 farExp
3437 #)
3438 in catchHandler inp farInp farExp
3439 in let readFail = catchHandler
3440 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 17 inp)
3441 then
3442 let !(#
3443 c,
3444 cs
3445 #) = readNext inp
3446 in if ('f' GHC.Classes.==) c
3447 then
3448 let readFail = readFail
3449 in let !(#
3450 c,
3451 cs
3452 #) = readNext cs
3453 in if ('u' GHC.Classes.==) c
3454 then
3455 let readFail = readFail
3456 in let !(#
3457 c,
3458 cs
3459 #) = readNext cs
3460 in if ('n' GHC.Classes.==) c
3461 then
3462 let readFail = readFail
3463 in let !(#
3464 c,
3465 cs
3466 #) = readNext cs
3467 in if ('c' GHC.Classes.==) c
3468 then
3469 let readFail = readFail
3470 in let !(#
3471 c,
3472 cs
3473 #) = readNext cs
3474 in if ('t' GHC.Classes.==) c
3475 then
3476 let readFail = readFail
3477 in let !(#
3478 c,
3479 cs
3480 #) = readNext cs
3481 in if ('i' GHC.Classes.==) c
3482 then
3483 let readFail = readFail
3484 in let !(#
3485 c,
3486 cs
3487 #) = readNext cs
3488 in if ('o' GHC.Classes.==) c
3489 then
3490 let readFail = readFail
3491 in let !(#
3492 c,
3493 cs
3494 #) = readNext cs
3495 in if ('n' GHC.Classes.==) c
3496 then
3497 name
3498 ( let _ = "suspend"
3499 in \farInp farExp v (!inp) ->
3500 name
3501 ( let _ = "suspend"
3502 in \farInp farExp v (!inp) ->
3503 name
3504 ( let _ = "suspend"
3505 in \farInp farExp v (!inp) ->
3506 name
3507 ( let _ = "suspend"
3508 in \farInp farExp v (!inp) ->
3509 let join = \farInp farExp v (!inp) ->
3510 name
3511 ( let _ = "suspend"
3512 in \farInp farExp v (!inp) ->
3513 name
3514 ( let _ = "suspend"
3515 in \farInp farExp v (!inp) ->
3516 name
3517 ( let _ = "suspend"
3518 in \farInp farExp v (!inp) ->
3519 let _ = "resume"
3520 in ok
3521 farInp
3522 farExp
3523 ( let _ = "resume.genCode"
3524 in \x -> v x
3525 )
3526 inp
3527 )
3528 inp
3529 Data.Map.Internal.Tip
3530 )
3531 inp
3532 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
3533 )
3534 inp
3535 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
3536 in let _ = "catchException lbl=fail"
3537 in let catchHandler (!failInp) (!farInp) (!farExp) =
3538 let _ = "catchException.ko lbl=fail"
3539 in if ( \( Data.Text.Internal.Text
3540 _
3541 i
3542 _
3543 )
3544 ( Data.Text.Internal.Text
3545 _
3546 j
3547 _
3548 ) -> i GHC.Classes.== j
3549 )
3550 inp
3551 failInp
3552 then
3553 let _ = "choicesBranch.then"
3554 in name
3555 ( let _ = "suspend"
3556 in \farInp farExp v (!inp) ->
3557 let _ = "resume"
3558 in join
3559 farInp
3560 farExp
3561 ( let _ = "resume.genCode"
3562 in v
3563 )
3564 inp
3565 )
3566 failInp
3567 Data.Map.Internal.Tip
3568 else
3569 let _ = "choicesBranch.else"
3570 in let (#
3571 farInp,
3572 farExp
3573 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
3574 GHC.Types.LT ->
3575 (#
3576 failInp,
3577 []
3578 #)
3579 GHC.Types.EQ ->
3580 (#
3581 farInp,
3582 farExp GHC.Base.<> []
3583 #)
3584 GHC.Types.GT ->
3585 (#
3586 farInp,
3587 farExp
3588 #)
3589 in catchHandler failInp farInp farExp
3590 in let readFail = catchHandler
3591 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
3592 then
3593 let !(#
3594 c,
3595 cs
3596 #) = readNext inp
3597 in if (':' GHC.Classes.==) c
3598 then
3599 name
3600 ( let _ = "suspend"
3601 in \farInp farExp v (!inp) ->
3602 name
3603 ( let _ = "suspend"
3604 in \farInp farExp v (!inp) ->
3605 let _ = "resume"
3606 in join
3607 farInp
3608 farExp
3609 ( let _ = "resume.genCode"
3610 in GHC.Tuple . ()
3611 )
3612 inp
3613 )
3614 inp
3615 Data.Map.Internal.Tip
3616 )
3617 cs
3618 (Data.Map.Internal.Bin 1 "fail" readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
3619 else
3620 let _ = "checkToken.else"
3621 in let (#
3622 farInp,
3623 farExp
3624 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
3625 GHC.Types.LT ->
3626 (#
3627 inp,
3628 [Symantic.Parser.Grammar.Combinators.ErrorItemToken ':']
3629 #)
3630 GHC.Types.EQ ->
3631 (#
3632 farInp,
3633 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken ':']
3634 #)
3635 GHC.Types.GT ->
3636 (#
3637 farInp,
3638 farExp
3639 #)
3640 in readFail inp farInp farExp
3641 else
3642 let _ = "checkHorizon.else"
3643 in let (#
3644 farInp,
3645 farExp
3646 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
3647 GHC.Types.LT ->
3648 (#
3649 inp,
3650 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
3651 #)
3652 GHC.Types.EQ ->
3653 (#
3654 farInp,
3655 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
3656 #)
3657 GHC.Types.GT ->
3658 (#
3659 farInp,
3660 farExp
3661 #)
3662 in readFail inp farInp farExp
3663 )
3664 inp
3665 Data.Map.Internal.Tip
3666 )
3667 inp
3668 (Data.Map.Internal.Bin 1 "fail" catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
3669 )
3670 inp
3671 Data.Map.Internal.Tip
3672 )
3673 cs
3674 Data.Map.Internal.Tip
3675 else
3676 let _ = "checkToken.else"
3677 in let (#
3678 farInp,
3679 farExp
3680 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3681 GHC.Types.LT ->
3682 (#
3683 cs,
3684 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'n']
3685 #)
3686 GHC.Types.EQ ->
3687 (#
3688 init,
3689 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'n']
3690 #)
3691 GHC.Types.GT ->
3692 (#
3693 init,
3694 GHC.Types . []
3695 #)
3696 in readFail cs farInp farExp
3697 else
3698 let _ = "checkToken.else"
3699 in let (#
3700 farInp,
3701 farExp
3702 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3703 GHC.Types.LT ->
3704 (#
3705 cs,
3706 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'o']
3707 #)
3708 GHC.Types.EQ ->
3709 (#
3710 init,
3711 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'o']
3712 #)
3713 GHC.Types.GT ->
3714 (#
3715 init,
3716 GHC.Types . []
3717 #)
3718 in readFail cs farInp farExp
3719 else
3720 let _ = "checkToken.else"
3721 in let (#
3722 farInp,
3723 farExp
3724 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3725 GHC.Types.LT ->
3726 (#
3727 cs,
3728 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'i']
3729 #)
3730 GHC.Types.EQ ->
3731 (#
3732 init,
3733 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'i']
3734 #)
3735 GHC.Types.GT ->
3736 (#
3737 init,
3738 GHC.Types . []
3739 #)
3740 in readFail cs farInp farExp
3741 else
3742 let _ = "checkToken.else"
3743 in let (#
3744 farInp,
3745 farExp
3746 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3747 GHC.Types.LT ->
3748 (#
3749 cs,
3750 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 't']
3751 #)
3752 GHC.Types.EQ ->
3753 (#
3754 init,
3755 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 't']
3756 #)
3757 GHC.Types.GT ->
3758 (#
3759 init,
3760 GHC.Types . []
3761 #)
3762 in readFail cs farInp farExp
3763 else
3764 let _ = "checkToken.else"
3765 in let (#
3766 farInp,
3767 farExp
3768 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3769 GHC.Types.LT ->
3770 (#
3771 cs,
3772 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'c']
3773 #)
3774 GHC.Types.EQ ->
3775 (#
3776 init,
3777 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'c']
3778 #)
3779 GHC.Types.GT ->
3780 (#
3781 init,
3782 GHC.Types . []
3783 #)
3784 in readFail cs farInp farExp
3785 else
3786 let _ = "checkToken.else"
3787 in let (#
3788 farInp,
3789 farExp
3790 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3791 GHC.Types.LT ->
3792 (#
3793 cs,
3794 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'n']
3795 #)
3796 GHC.Types.EQ ->
3797 (#
3798 init,
3799 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'n']
3800 #)
3801 GHC.Types.GT ->
3802 (#
3803 init,
3804 GHC.Types . []
3805 #)
3806 in readFail cs farInp farExp
3807 else
3808 let _ = "checkToken.else"
3809 in let (#
3810 farInp,
3811 farExp
3812 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
3813 GHC.Types.LT ->
3814 (#
3815 cs,
3816 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'u']
3817 #)
3818 GHC.Types.EQ ->
3819 (#
3820 init,
3821 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'u']
3822 #)
3823 GHC.Types.GT ->
3824 (#
3825 init,
3826 GHC.Types . []
3827 #)
3828 in readFail cs farInp farExp
3829 else
3830 let _ = "checkToken.else"
3831 in let (#
3832 farInp,
3833 farExp
3834 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3835 GHC.Types.LT ->
3836 (#
3837 inp,
3838 [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'f']
3839 #)
3840 GHC.Types.EQ ->
3841 (#
3842 init,
3843 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'f']
3844 #)
3845 GHC.Types.GT ->
3846 (#
3847 init,
3848 GHC.Types . []
3849 #)
3850 in readFail inp farInp farExp
3851 else
3852 let _ = "checkHorizon.else"
3853 in let (#
3854 farInp,
3855 farExp
3856 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3857 GHC.Types.LT ->
3858 (#
3859 inp,
3860 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 18]
3861 #)
3862 GHC.Types.EQ ->
3863 (#
3864 init,
3865 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 18]
3866 #)
3867 GHC.Types.GT ->
3868 (#
3869 init,
3870 GHC.Types . []
3871 #)
3872 in readFail inp farInp farExp
3873 name = \(!ok) (!inp) (!koByLabel) ->
3874 let _ = "catchException lbl=fail"
3875 in let catchHandler (!failInp) (!farInp) (!farExp) =
3876 let _ = "catchException.ko lbl=fail"
3877 in let (#
3878 farInp,
3879 farExp
3880 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
3881 GHC.Types.LT ->
3882 (#
3883 inp,
3884 []
3885 #)
3886 GHC.Types.EQ ->
3887 (#
3888 farInp,
3889 farExp GHC.Base.<> []
3890 #)
3891 GHC.Types.GT ->
3892 (#
3893 farInp,
3894 farExp
3895 #)
3896 in finalRaise inp farInp farExp
3897 in let readFail = catchHandler
3898 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
3899 then
3900 let !(#
3901 c,
3902 cs
3903 #) = readNext inp
3904 in if Grammar.Nandlang.nandIdentStart c
3905 then
3906 name
3907 ( let _ = "suspend"
3908 in \farInp farExp v (!inp) ->
3909 name
3910 ( let _ = "suspend"
3911 in \farInp farExp v (!inp) ->
3912 name
3913 ( let _ = "suspend"
3914 in \farInp farExp v (!inp) ->
3915 name
3916 ( let _ = "suspend"
3917 in \farInp farExp v (!inp) ->
3918 let _ = "resume"
3919 in ok
3920 farInp
3921 farExp
3922 ( let _ = "resume.genCode"
3923 in v
3924 )
3925 inp
3926 )
3927 inp
3928 Data.Map.Internal.Tip
3929 )
3930 inp
3931 Data.Map.Internal.Tip
3932 )
3933 inp
3934 Data.Map.Internal.Tip
3935 )
3936 cs
3937 Data.Map.Internal.Tip
3938 else
3939 let _ = "checkToken.else"
3940 in let (#
3941 farInp,
3942 farExp
3943 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3944 GHC.Types.LT ->
3945 (#
3946 inp,
3947 [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "identStart"]
3948 #)
3949 GHC.Types.EQ ->
3950 (#
3951 init,
3952 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemLabel "identStart"]
3953 #)
3954 GHC.Types.GT ->
3955 (#
3956 init,
3957 GHC.Types . []
3958 #)
3959 in readFail inp farInp farExp
3960 else
3961 let _ = "checkHorizon.else"
3962 in let (#
3963 farInp,
3964 farExp
3965 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
3966 GHC.Types.LT ->
3967 (#
3968 inp,
3969 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
3970 #)
3971 GHC.Types.EQ ->
3972 (#
3973 init,
3974 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
3975 #)
3976 GHC.Types.GT ->
3977 (#
3978 init,
3979 GHC.Types . []
3980 #)
3981 in readFail inp farInp farExp
3982 name = \(!ok) (!inp) (!koByLabel) ->
3983 let _ = "resume"
3984 in ok init GHC.Types
3985 . []
3986 ( let _ = "resume.genCode"
3987 in GHC.Tuple . ()
3988 )
3989 inp
3990 name = \(!ok) (!inp) (!koByLabel) ->
3991 let _ = "resume"
3992 in ok init GHC.Types
3993 . []
3994 ( let _ = "resume.genCode"
3995 in GHC.Tuple . ()
3996 )
3997 inp
3998 name = \(!ok) (!inp) (!koByLabel) ->
3999 let _ = "resume"
4000 in ok init GHC.Types
4001 . []
4002 ( let _ = "resume.genCode"
4003 in \x -> \x -> x
4004 )
4005 inp
4006 in name
4007 ( let _ = "suspend"
4008 in \farInp farExp v (!inp) ->
4009 name
4010 ( let _ = "suspend"
4011 in \farInp farExp v (!inp) ->
4012 name
4013 ( let _ = "suspend"
4014 in \farInp farExp v (!inp) ->
4015 name
4016 ( let _ = "suspend"
4017 in \farInp farExp v (!inp) ->
4018 let join = \farInp farExp v (!inp) ->
4019 let _ = "resume"
4020 in finalRet
4021 farInp
4022 farExp
4023 ( let _ = "resume.genCode"
4024 in GHC.Show.show v
4025 )
4026 inp
4027 in let _ = "catchException lbl=fail"
4028 in let catchHandler (!failInp) (!farInp) (!farExp) =
4029 let _ = "catchException.ko lbl=fail"
4030 in if ( \( Data.Text.Internal.Text
4031 _
4032 i
4033 _
4034 )
4035 ( Data.Text.Internal.Text
4036 _
4037 j
4038 _
4039 ) -> i GHC.Classes.== j
4040 )
4041 inp
4042 failInp
4043 then
4044 let _ = "choicesBranch.then"
4045 in let (#
4046 farInp,
4047 farExp
4048 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
4049 GHC.Types.LT ->
4050 (#
4051 failInp,
4052 [Symantic.Parser.Grammar.Combinators.ErrorItemEnd]
4053 #)
4054 GHC.Types.EQ ->
4055 (#
4056 farInp,
4057 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemEnd]
4058 #)
4059 GHC.Types.GT ->
4060 (#
4061 farInp,
4062 farExp
4063 #)
4064 in finalRaise failInp farInp farExp
4065 else
4066 let _ = "choicesBranch.else"
4067 in let (#
4068 farInp,
4069 farExp
4070 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
4071 GHC.Types.LT ->
4072 (#
4073 failInp,
4074 []
4075 #)
4076 GHC.Types.EQ ->
4077 (#
4078 farInp,
4079 farExp GHC.Base.<> []
4080 #)
4081 GHC.Types.GT ->
4082 (#
4083 farInp,
4084 farExp
4085 #)
4086 in finalRaise failInp farInp farExp
4087 in let _ = "catchException lbl=fail"
4088 in let catchHandler (!failInp) (!farInp) (!farExp) =
4089 let _ = "catchException.ko lbl=fail"
4090 in let _ = "resume"
4091 in join
4092 farInp
4093 farExp
4094 ( let _ = "resume.genCode"
4095 in GHC.Tuple . ()
4096 )
4097 inp
4098 in let readFail = catchHandler
4099 in if readMore inp
4100 then
4101 let !(#
4102 c,
4103 cs
4104 #) = readNext inp
4105 in if (\x -> GHC.Types.True) c
4106 then
4107 let (#
4108 farInp,
4109 farExp
4110 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
4111 GHC.Types.LT ->
4112 (#
4113 inp,
4114 []
4115 #)
4116 GHC.Types.EQ ->
4117 (#
4118 farInp,
4119 farExp GHC.Base.<> []
4120 #)
4121 GHC.Types.GT ->
4122 (#
4123 farInp,
4124 farExp
4125 #)
4126 in catchHandler inp farInp farExp
4127 else
4128 let _ = "checkToken.else"
4129 in let (#
4130 farInp,
4131 farExp
4132 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
4133 GHC.Types.LT ->
4134 (#
4135 inp,
4136 []
4137 #)
4138 GHC.Types.EQ ->
4139 (#
4140 farInp,
4141 farExp GHC.Base.<> []
4142 #)
4143 GHC.Types.GT ->
4144 (#
4145 farInp,
4146 farExp
4147 #)
4148 in readFail inp farInp farExp
4149 else
4150 let _ = "checkHorizon.else"
4151 in let (#
4152 farInp,
4153 farExp
4154 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
4155 GHC.Types.LT ->
4156 (#
4157 inp,
4158 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
4159 #)
4160 GHC.Types.EQ ->
4161 (#
4162 farInp,
4163 farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
4164 #)
4165 GHC.Types.GT ->
4166 (#
4167 farInp,
4168 farExp
4169 #)
4170 in readFail inp farInp farExp
4171 )
4172 inp
4173 Data.Map.Internal.Tip
4174 )
4175 inp
4176 Data.Map.Internal.Tip
4177 )
4178 inp
4179 Data.Map.Internal.Tip
4180 )
4181 init
4182 Data.Map.Internal.Tip
Library for parsing