-
Notifications
You must be signed in to change notification settings - Fork 1
/
Parser.hs
723 lines (502 loc) · 17.8 KB
/
Parser.hs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
{-# OPTIONS_GHC -w #-}
{-
ASN.2 - 2016
(C) Copyright Buster Kim Mejborn 2016
All Rights Reserved.
-}
module Parser where
import Lexer
import Ast
import Control.Applicative(Applicative(..))
import Control.Monad (ap)
-- parser produced by Happy Version 1.19.5
data HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16
= HappyTerminal (Token)
| HappyErrorToken Int
| HappyAbsSyn4 t4
| HappyAbsSyn5 t5
| HappyAbsSyn6 t6
| HappyAbsSyn7 t7
| HappyAbsSyn8 t8
| HappyAbsSyn9 t9
| HappyAbsSyn10 t10
| HappyAbsSyn11 t11
| HappyAbsSyn12 t12
| HappyAbsSyn13 t13
| HappyAbsSyn14 t14
| HappyAbsSyn15 t15
| HappyAbsSyn16 t16
action_0 (17) = happyShift action_4
action_0 (4) = happyGoto action_5
action_0 (5) = happyGoto action_2
action_0 (6) = happyGoto action_3
action_0 _ = happyFail
action_1 (17) = happyShift action_4
action_1 (5) = happyGoto action_2
action_1 (6) = happyGoto action_3
action_1 _ = happyFail
action_2 (17) = happyShift action_4
action_2 (6) = happyGoto action_7
action_2 _ = happyReduce_1
action_3 _ = happyReduce_2
action_4 (18) = happyShift action_6
action_4 _ = happyFail
action_5 (28) = happyAccept
action_5 _ = happyFail
action_6 (17) = happyShift action_11
action_6 (19) = happyShift action_12
action_6 (7) = happyGoto action_8
action_6 (8) = happyGoto action_9
action_6 (9) = happyGoto action_10
action_6 _ = happyFail
action_7 _ = happyReduce_3
action_8 _ = happyReduce_8
action_9 (19) = happyShift action_15
action_9 _ = happyFail
action_10 (22) = happyShift action_14
action_10 _ = happyReduce_7
action_11 _ = happyReduce_6
action_12 (23) = happyShift action_13
action_12 _ = happyFail
action_13 (26) = happyShift action_19
action_13 (27) = happyShift action_20
action_13 (10) = happyGoto action_18
action_13 _ = happyFail
action_14 (17) = happyShift action_11
action_14 (7) = happyGoto action_17
action_14 _ = happyFail
action_15 (23) = happyShift action_16
action_15 _ = happyFail
action_16 (26) = happyShift action_19
action_16 (27) = happyShift action_20
action_16 (10) = happyGoto action_23
action_16 _ = happyFail
action_17 _ = happyReduce_9
action_18 _ = happyReduce_4
action_19 (20) = happyShift action_22
action_19 _ = happyFail
action_20 (20) = happyShift action_21
action_20 _ = happyFail
action_21 (17) = happyShift action_31
action_21 (24) = happyShift action_32
action_21 (11) = happyGoto action_28
action_21 (12) = happyGoto action_29
action_21 (13) = happyGoto action_30
action_21 _ = happyFail
action_22 (17) = happyShift action_27
action_22 (14) = happyGoto action_24
action_22 (15) = happyGoto action_25
action_22 (16) = happyGoto action_26
action_22 _ = happyFail
action_23 _ = happyReduce_5
action_24 _ = happyReduce_20
action_25 (21) = happyShift action_39
action_25 _ = happyFail
action_26 (22) = happyShift action_38
action_26 _ = happyReduce_19
action_27 (18) = happyShift action_37
action_27 _ = happyFail
action_28 _ = happyReduce_16
action_29 (21) = happyShift action_36
action_29 _ = happyFail
action_30 (22) = happyShift action_35
action_30 _ = happyReduce_15
action_31 (20) = happyShift action_34
action_31 _ = happyFail
action_32 (18) = happyShift action_33
action_32 _ = happyFail
action_33 (17) = happyShift action_45
action_33 _ = happyFail
action_34 (17) = happyShift action_43
action_34 (25) = happyShift action_44
action_34 _ = happyFail
action_35 (17) = happyShift action_31
action_35 (24) = happyShift action_32
action_35 (11) = happyGoto action_42
action_35 _ = happyFail
action_36 _ = happyReduce_10
action_37 (17) = happyShift action_41
action_37 _ = happyFail
action_38 (17) = happyShift action_27
action_38 (14) = happyGoto action_40
action_38 _ = happyFail
action_39 _ = happyReduce_11
action_40 _ = happyReduce_21
action_41 (19) = happyShift action_49
action_41 _ = happyFail
action_42 _ = happyReduce_17
action_43 (21) = happyShift action_48
action_43 _ = happyFail
action_44 (17) = happyShift action_47
action_44 _ = happyFail
action_45 (19) = happyShift action_46
action_45 _ = happyFail
action_46 _ = happyReduce_12
action_47 (21) = happyShift action_50
action_47 _ = happyFail
action_48 _ = happyReduce_13
action_49 _ = happyReduce_18
action_50 _ = happyReduce_14
happyReduce_1 = happySpecReduce_1 4 happyReduction_1
happyReduction_1 (HappyAbsSyn5 happy_var_1)
= HappyAbsSyn4
(reverse happy_var_1
)
happyReduction_1 _ = notHappyAtAll
happyReduce_2 = happySpecReduce_1 5 happyReduction_2
happyReduction_2 (HappyAbsSyn6 happy_var_1)
= HappyAbsSyn5
(happy_var_1 : []
)
happyReduction_2 _ = notHappyAtAll
happyReduce_3 = happySpecReduce_2 5 happyReduction_3
happyReduction_3 (HappyAbsSyn6 happy_var_2)
(HappyAbsSyn5 happy_var_1)
= HappyAbsSyn5
(happy_var_2 : happy_var_1
)
happyReduction_3 _ _ = notHappyAtAll
happyReduce_4 = happyReduce 5 6 happyReduction_4
happyReduction_4 ((HappyAbsSyn10 happy_var_5) `HappyStk`
_ `HappyStk`
_ `HappyStk`
_ `HappyStk`
(HappyTerminal (TATOM _ happy_var_1)) `HappyStk`
happyRest)
= HappyAbsSyn6
(Format happy_var_1 [] happy_var_5
) `HappyStk` happyRest
happyReduce_5 = happyReduce 6 6 happyReduction_5
happyReduction_5 ((HappyAbsSyn10 happy_var_6) `HappyStk`
_ `HappyStk`
_ `HappyStk`
(HappyAbsSyn8 happy_var_3) `HappyStk`
_ `HappyStk`
(HappyTerminal (TATOM _ happy_var_1)) `HappyStk`
happyRest)
= HappyAbsSyn6
(Format happy_var_1 happy_var_3 happy_var_6
) `HappyStk` happyRest
happyReduce_6 = happySpecReduce_1 7 happyReduction_6
happyReduction_6 (HappyTerminal (TATOM _ happy_var_1))
= HappyAbsSyn7
(happy_var_1
)
happyReduction_6 _ = notHappyAtAll
happyReduce_7 = happySpecReduce_1 8 happyReduction_7
happyReduction_7 (HappyAbsSyn9 happy_var_1)
= HappyAbsSyn8
(reverse happy_var_1
)
happyReduction_7 _ = notHappyAtAll
happyReduce_8 = happySpecReduce_1 9 happyReduction_8
happyReduction_8 (HappyAbsSyn7 happy_var_1)
= HappyAbsSyn9
(happy_var_1 : []
)
happyReduction_8 _ = notHappyAtAll
happyReduce_9 = happySpecReduce_3 9 happyReduction_9
happyReduction_9 (HappyAbsSyn7 happy_var_3)
_
(HappyAbsSyn9 happy_var_1)
= HappyAbsSyn9
(happy_var_3 : happy_var_1
)
happyReduction_9 _ _ _ = notHappyAtAll
happyReduce_10 = happyReduce 4 10 happyReduction_10
happyReduction_10 (_ `HappyStk`
(HappyAbsSyn12 happy_var_3) `HappyStk`
_ `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn10
(ASN1 happy_var_3
) `HappyStk` happyRest
happyReduce_11 = happyReduce 4 10 happyReduction_11
happyReduction_11 (_ `HappyStk`
(HappyAbsSyn15 happy_var_3) `HappyStk`
_ `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn10
(XML happy_var_3
) `HappyStk` happyRest
happyReduce_12 = happyReduce 4 11 happyReduction_12
happyReduction_12 (_ `HappyStk`
(HappyTerminal (TATOM _ happy_var_3)) `HappyStk`
_ `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn11
(Byte (read happy_var_3)
) `HappyStk` happyRest
happyReduce_13 = happyReduce 4 11 happyReduction_13
happyReduction_13 (_ `HappyStk`
(HappyTerminal (TATOM _ happy_var_3)) `HappyStk`
_ `HappyStk`
(HappyTerminal (TATOM _ happy_var_1)) `HappyStk`
happyRest)
= HappyAbsSyn11
(Fixed happy_var_1 (read happy_var_3)
) `HappyStk` happyRest
happyReduce_14 = happyReduce 5 11 happyReduction_14
happyReduction_14 (_ `HappyStk`
(HappyTerminal (TATOM _ happy_var_4)) `HappyStk`
_ `HappyStk`
_ `HappyStk`
(HappyTerminal (TATOM _ happy_var_1)) `HappyStk`
happyRest)
= HappyAbsSyn11
(LengthF happy_var_1 (read happy_var_4)
) `HappyStk` happyRest
happyReduce_15 = happySpecReduce_1 12 happyReduction_15
happyReduction_15 (HappyAbsSyn13 happy_var_1)
= HappyAbsSyn12
(reverse happy_var_1
)
happyReduction_15 _ = notHappyAtAll
happyReduce_16 = happySpecReduce_1 13 happyReduction_16
happyReduction_16 (HappyAbsSyn11 happy_var_1)
= HappyAbsSyn13
(happy_var_1 : []
)
happyReduction_16 _ = notHappyAtAll
happyReduce_17 = happySpecReduce_3 13 happyReduction_17
happyReduction_17 (HappyAbsSyn11 happy_var_3)
_
(HappyAbsSyn13 happy_var_1)
= HappyAbsSyn13
(happy_var_3 : happy_var_1
)
happyReduction_17 _ _ _ = notHappyAtAll
happyReduce_18 = happyReduce 4 14 happyReduction_18
happyReduction_18 (_ `HappyStk`
(HappyTerminal (TATOM _ happy_var_3)) `HappyStk`
_ `HappyStk`
(HappyTerminal (TATOM _ happy_var_1)) `HappyStk`
happyRest)
= HappyAbsSyn14
(Unbounded happy_var_1 happy_var_3
) `HappyStk` happyRest
happyReduce_19 = happySpecReduce_1 15 happyReduction_19
happyReduction_19 (HappyAbsSyn16 happy_var_1)
= HappyAbsSyn15
(reverse happy_var_1
)
happyReduction_19 _ = notHappyAtAll
happyReduce_20 = happySpecReduce_1 16 happyReduction_20
happyReduction_20 (HappyAbsSyn14 happy_var_1)
= HappyAbsSyn16
(happy_var_1 : []
)
happyReduction_20 _ = notHappyAtAll
happyReduce_21 = happySpecReduce_3 16 happyReduction_21
happyReduction_21 (HappyAbsSyn14 happy_var_3)
_
(HappyAbsSyn16 happy_var_1)
= HappyAbsSyn16
(happy_var_3 : happy_var_1
)
happyReduction_21 _ _ _ = notHappyAtAll
happyNewToken action sts stk [] =
action 28 28 notHappyAtAll (HappyState action) sts stk []
happyNewToken action sts stk (tk:tks) =
let cont i = action i i tk (HappyState action) sts stk tks in
case tk of {
TATOM _ happy_dollar_dollar -> cont 17;
TOPENP _ -> cont 18;
TCLOSEP _ -> cont 19;
TOPENSQ _ -> cont 20;
TCLOSESQ _ -> cont 21;
TCOMMA _ -> cont 22;
TEQ _ -> cont 23;
TBYTE _ -> cont 24;
TSTAR _ -> cont 25;
TXML _ -> cont 26;
TASN1 _ -> cont 27;
_ -> happyError' (tk:tks)
}
happyError_ 28 tk tks = happyError' tks
happyError_ _ tk tks = happyError' (tk:tks)
newtype HappyIdentity a = HappyIdentity a
happyIdentity = HappyIdentity
happyRunIdentity (HappyIdentity a) = a
instance Functor HappyIdentity where
fmap f (HappyIdentity a) = HappyIdentity (f a)
instance Applicative HappyIdentity where
pure = return
(<*>) = ap
instance Monad HappyIdentity where
return = HappyIdentity
(HappyIdentity p) >>= q = q p
happyThen :: () => HappyIdentity a -> (a -> HappyIdentity b) -> HappyIdentity b
happyThen = (>>=)
happyReturn :: () => a -> HappyIdentity a
happyReturn = (return)
happyThen1 m k tks = (>>=) m (\a -> k a tks)
happyReturn1 :: () => a -> b -> HappyIdentity a
happyReturn1 = \a tks -> (return) a
happyError' :: () => [(Token)] -> HappyIdentity a
happyError' = HappyIdentity . happyError
parser tks = happyRunIdentity happySomeParser where
happySomeParser = happyThen (happyParse action_0 tks) (\x -> case x of {HappyAbsSyn4 z -> happyReturn z; _other -> notHappyAtAll })
happySeq = happyDontSeq
happyError :: [Token] -> a
happyError tks = error ("Parse error at " ++ lcn ++ "\n" )
where
lcn = case tks of
[] -> "end of file"
tk:_ -> "line " ++ show l ++ ", column " ++ show c ++ " - Token: " ++ show tk
where
AlexPn _ l c = token_posn tk
{-# LINE 1 "templates/GenericTemplate.hs" #-}
{-# LINE 1 "templates/GenericTemplate.hs" #-}
{-# LINE 1 "<built-in>" #-}
{-# LINE 1 "<command-line>" #-}
{-# LINE 8 "<command-line>" #-}
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 17 "/usr/include/stdc-predef.h" 3 4
{-# LINE 8 "<command-line>" #-}
{-# LINE 1 "/usr/lib/ghc-7.10.3/include/ghcversion.h" #-}
{-# LINE 8 "<command-line>" #-}
{-# LINE 1 "templates/GenericTemplate.hs" #-}
-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp
{-# LINE 13 "templates/GenericTemplate.hs" #-}
{-# LINE 46 "templates/GenericTemplate.hs" #-}
{-# LINE 67 "templates/GenericTemplate.hs" #-}
{-# LINE 77 "templates/GenericTemplate.hs" #-}
{-# LINE 86 "templates/GenericTemplate.hs" #-}
infixr 9 `HappyStk`
data HappyStk a = HappyStk a (HappyStk a)
-----------------------------------------------------------------------------
-- starting the parse
happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll
-----------------------------------------------------------------------------
-- Accepting the parse
-- If the current token is (1), it means we've just accepted a partial
-- parse (a %partial parser). We must ignore the saved token on the top of
-- the stack in this case.
happyAccept (1) tk st sts (_ `HappyStk` ans `HappyStk` _) =
happyReturn1 ans
happyAccept j tk st sts (HappyStk ans _) =
(happyReturn1 ans)
-----------------------------------------------------------------------------
-- Arrays only: do the next action
{-# LINE 155 "templates/GenericTemplate.hs" #-}
-----------------------------------------------------------------------------
-- HappyState data type (not arrays)
newtype HappyState b c = HappyState
(Int -> -- token number
Int -> -- token number (yes, again)
b -> -- token semantic value
HappyState b c -> -- current state
[HappyState b c] -> -- state stack
c)
-----------------------------------------------------------------------------
-- Shifting a token
happyShift new_state (1) tk st sts stk@(x `HappyStk` _) =
let i = (case x of { HappyErrorToken (i) -> i }) in
-- trace "shifting the error token" $
new_state i i tk (HappyState (new_state)) ((st):(sts)) (stk)
happyShift new_state i tk st sts stk =
happyNewToken new_state ((st):(sts)) ((HappyTerminal (tk))`HappyStk`stk)
-- happyReduce is specialised for the common cases.
happySpecReduce_0 i fn (1) tk st sts stk
= happyFail (1) tk st sts stk
happySpecReduce_0 nt fn j tk st@((HappyState (action))) sts stk
= action nt j tk st ((st):(sts)) (fn `HappyStk` stk)
happySpecReduce_1 i fn (1) tk st sts stk
= happyFail (1) tk st sts stk
happySpecReduce_1 nt fn j tk _ sts@(((st@(HappyState (action))):(_))) (v1`HappyStk`stk')
= let r = fn v1 in
happySeq r (action nt j tk st sts (r `HappyStk` stk'))
happySpecReduce_2 i fn (1) tk st sts stk
= happyFail (1) tk st sts stk
happySpecReduce_2 nt fn j tk _ ((_):(sts@(((st@(HappyState (action))):(_))))) (v1`HappyStk`v2`HappyStk`stk')
= let r = fn v1 v2 in
happySeq r (action nt j tk st sts (r `HappyStk` stk'))
happySpecReduce_3 i fn (1) tk st sts stk
= happyFail (1) tk st sts stk
happySpecReduce_3 nt fn j tk _ ((_):(((_):(sts@(((st@(HappyState (action))):(_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')
= let r = fn v1 v2 v3 in
happySeq r (action nt j tk st sts (r `HappyStk` stk'))
happyReduce k i fn (1) tk st sts stk
= happyFail (1) tk st sts stk
happyReduce k nt fn j tk st sts stk
= case happyDrop (k - ((1) :: Int)) sts of
sts1@(((st1@(HappyState (action))):(_))) ->
let r = fn stk in -- it doesn't hurt to always seq here...
happyDoSeq r (action nt j tk st1 sts1 r)
happyMonadReduce k nt fn (1) tk st sts stk
= happyFail (1) tk st sts stk
happyMonadReduce k nt fn j tk st sts stk =
case happyDrop k ((st):(sts)) of
sts1@(((st1@(HappyState (action))):(_))) ->
let drop_stk = happyDropStk k stk in
happyThen1 (fn stk tk) (\r -> action nt j tk st1 sts1 (r `HappyStk` drop_stk))
happyMonad2Reduce k nt fn (1) tk st sts stk
= happyFail (1) tk st sts stk
happyMonad2Reduce k nt fn j tk st sts stk =
case happyDrop k ((st):(sts)) of
sts1@(((st1@(HappyState (action))):(_))) ->
let drop_stk = happyDropStk k stk
new_state = action
in
happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))
happyDrop (0) l = l
happyDrop n ((_):(t)) = happyDrop (n - ((1) :: Int)) t
happyDropStk (0) l = l
happyDropStk n (x `HappyStk` xs) = happyDropStk (n - ((1)::Int)) xs
-----------------------------------------------------------------------------
-- Moving to a new state after a reduction
{-# LINE 256 "templates/GenericTemplate.hs" #-}
happyGoto action j tk st = action j j tk (HappyState action)
-----------------------------------------------------------------------------
-- Error recovery ((1) is the error token)
-- parse error if we are in recovery and we fail again
happyFail (1) tk old_st _ stk@(x `HappyStk` _) =
let i = (case x of { HappyErrorToken (i) -> i }) in
-- trace "failing" $
happyError_ i tk
{- We don't need state discarding for our restricted implementation of
"error". In fact, it can cause some bogus parses, so I've disabled it
for now --SDM
-- discard a state
happyFail (1) tk old_st (((HappyState (action))):(sts))
(saved_tok `HappyStk` _ `HappyStk` stk) =
-- trace ("discarding state, depth " ++ show (length stk)) $
action (1) (1) tk (HappyState (action)) sts ((saved_tok`HappyStk`stk))
-}
-- Enter error recovery: generate an error token,
-- save the old token and carry on.
happyFail i tk (HappyState (action)) sts stk =
-- trace "entering error recovery" $
action (1) (1) tk (HappyState (action)) sts ( (HappyErrorToken (i)) `HappyStk` stk)
-- Internal happy errors:
notHappyAtAll :: a
notHappyAtAll = error "Internal Happy error\n"
-----------------------------------------------------------------------------
-- Hack to get the typechecker to accept our action functions
-----------------------------------------------------------------------------
-- Seq-ing. If the --strict flag is given, then Happy emits
-- happySeq = happyDoSeq
-- otherwise it emits
-- happySeq = happyDontSeq
happyDoSeq, happyDontSeq :: a -> b -> b
happyDoSeq a b = a `seq` b
happyDontSeq a b = b
-----------------------------------------------------------------------------
-- Don't inline any functions from the template. GHC has a nasty habit
-- of deciding to inline happyGoto everywhere, which increases the size of
-- the generated parser quite a bit.
{-# LINE 322 "templates/GenericTemplate.hs" #-}
{-# NOINLINE happyShift #-}
{-# NOINLINE happySpecReduce_0 #-}
{-# NOINLINE happySpecReduce_1 #-}
{-# NOINLINE happySpecReduce_2 #-}
{-# NOINLINE happySpecReduce_3 #-}
{-# NOINLINE happyReduce #-}
{-# NOINLINE happyMonadReduce #-}
{-# NOINLINE happyGoto #-}
{-# NOINLINE happyFail #-}
-- end of Happy Template.