-
Notifications
You must be signed in to change notification settings - Fork 0
/
Parser.hs
490 lines (372 loc) · 13.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
{-# OPTIONS_GHC -w #-}
module Parser (parser) where
import Types
import Lexer
-- parser produced by Happy Version 1.18.10
data HappyAbsSyn t4 t5 t6 t7 t8 t9 t10
= HappyTerminal (Token)
| HappyErrorToken Int
| HappyAbsSyn4 t4
| HappyAbsSyn5 t5
| HappyAbsSyn6 t6
| HappyAbsSyn7 t7
| HappyAbsSyn8 t8
| HappyAbsSyn9 t9
| HappyAbsSyn10 t10
action_0 (4) = happyGoto action_3
action_0 (5) = happyGoto action_2
action_0 _ = happyReduce_2
action_1 (5) = happyGoto action_2
action_1 _ = happyFail
action_2 (11) = happyShift action_5
action_2 (20) = happyShift action_6
action_2 (6) = happyGoto action_4
action_2 _ = happyReduce_1
action_3 (25) = happyAccept
action_3 _ = happyFail
action_4 _ = happyReduce_3
action_5 (15) = happyShift action_12
action_5 (20) = happyShift action_13
action_5 (7) = happyGoto action_8
action_5 (8) = happyGoto action_9
action_5 (9) = happyGoto action_10
action_5 (10) = happyGoto action_11
action_5 _ = happyFail
action_6 (18) = happyShift action_7
action_6 _ = happyFail
action_7 (15) = happyShift action_12
action_7 (20) = happyShift action_13
action_7 (7) = happyGoto action_19
action_7 (8) = happyGoto action_9
action_7 _ = happyFail
action_8 (19) = happyShift action_17
action_8 (22) = happyShift action_18
action_8 _ = happyFail
action_9 _ = happyReduce_7
action_10 (12) = happyShift action_16
action_10 _ = happyFail
action_11 (24) = happyShift action_15
action_11 _ = happyReduce_12
action_12 (15) = happyShift action_12
action_12 (20) = happyShift action_13
action_12 (7) = happyGoto action_14
action_12 (8) = happyGoto action_9
action_12 _ = happyFail
action_13 _ = happyReduce_9
action_14 (16) = happyShift action_25
action_14 (19) = happyShift action_17
action_14 _ = happyFail
action_15 (15) = happyShift action_12
action_15 (20) = happyShift action_13
action_15 (7) = happyGoto action_8
action_15 (8) = happyGoto action_9
action_15 (9) = happyGoto action_24
action_15 (10) = happyGoto action_11
action_15 _ = happyFail
action_16 (15) = happyShift action_23
action_16 _ = happyFail
action_17 (15) = happyShift action_12
action_17 (20) = happyShift action_13
action_17 (8) = happyGoto action_22
action_17 _ = happyFail
action_18 (15) = happyShift action_12
action_18 (20) = happyShift action_13
action_18 (7) = happyGoto action_21
action_18 (8) = happyGoto action_9
action_18 _ = happyFail
action_19 (17) = happyShift action_20
action_19 (19) = happyShift action_17
action_19 _ = happyReduce_5
action_20 _ = happyReduce_4
action_21 (19) = happyShift action_17
action_21 _ = happyReduce_13
action_22 _ = happyReduce_8
action_23 (5) = happyGoto action_26
action_23 _ = happyReduce_2
action_24 _ = happyReduce_11
action_25 _ = happyReduce_10
action_26 (11) = happyShift action_5
action_26 (16) = happyShift action_27
action_26 (20) = happyShift action_6
action_26 (6) = happyGoto action_4
action_26 _ = happyFail
action_27 _ = happyReduce_6
happyReduce_1 = happySpecReduce_1 4 happyReduction_1
happyReduction_1 (HappyAbsSyn5 happy_var_1)
= HappyAbsSyn4
(Program happy_var_1
)
happyReduction_1 _ = notHappyAtAll
happyReduce_2 = happySpecReduce_0 5 happyReduction_2
happyReduction_2 = HappyAbsSyn5
([]
)
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 4 6 happyReduction_4
happyReduction_4 (_ `HappyStk`
(HappyAbsSyn7 happy_var_3) `HappyStk`
_ `HappyStk`
(HappyTerminal (Var _ happy_var_1)) `HappyStk`
happyRest)
= HappyAbsSyn6
(Sass happy_var_1 happy_var_3
) `HappyStk` happyRest
happyReduce_5 = happySpecReduce_3 6 happyReduction_5
happyReduction_5 (HappyAbsSyn7 happy_var_3)
_
(HappyTerminal (Var _ happy_var_1))
= HappyAbsSyn6
(Sass happy_var_1 happy_var_3
)
happyReduction_5 _ _ _ = notHappyAtAll
happyReduce_6 = happyReduce 6 6 happyReduction_6
happyReduction_6 (_ `HappyStk`
(HappyAbsSyn5 happy_var_5) `HappyStk`
_ `HappyStk`
_ `HappyStk`
(HappyAbsSyn9 happy_var_2) `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn6
(Swhile happy_var_2 happy_var_5
) `HappyStk` happyRest
happyReduce_7 = happySpecReduce_1 7 happyReduction_7
happyReduction_7 (HappyAbsSyn8 happy_var_1)
= HappyAbsSyn7
(happy_var_1
)
happyReduction_7 _ = notHappyAtAll
happyReduce_8 = happySpecReduce_3 7 happyReduction_8
happyReduction_8 (HappyAbsSyn8 happy_var_3)
(HappyTerminal (Sym _ happy_var_2))
(HappyAbsSyn7 happy_var_1)
= HappyAbsSyn7
(Aop happy_var_2 happy_var_1 happy_var_3
)
happyReduction_8 _ _ _ = notHappyAtAll
happyReduce_9 = happySpecReduce_1 8 happyReduction_9
happyReduction_9 (HappyTerminal (Var _ happy_var_1))
= HappyAbsSyn8
(Variable happy_var_1
)
happyReduction_9 _ = notHappyAtAll
happyReduce_10 = happySpecReduce_3 8 happyReduction_10
happyReduction_10 _
(HappyAbsSyn7 happy_var_2)
_
= HappyAbsSyn8
(happy_var_2
)
happyReduction_10 _ _ _ = notHappyAtAll
happyReduce_11 = happySpecReduce_3 9 happyReduction_11
happyReduction_11 (HappyAbsSyn9 happy_var_3)
_
(HappyAbsSyn10 happy_var_1)
= HappyAbsSyn9
(Band happy_var_1 happy_var_3
)
happyReduction_11 _ _ _ = notHappyAtAll
happyReduce_12 = happySpecReduce_1 9 happyReduction_12
happyReduction_12 (HappyAbsSyn10 happy_var_1)
= HappyAbsSyn9
(happy_var_1
)
happyReduction_12 _ = notHappyAtAll
happyReduce_13 = happySpecReduce_3 10 happyReduction_13
happyReduction_13 (HappyAbsSyn7 happy_var_3)
_
(HappyAbsSyn7 happy_var_1)
= HappyAbsSyn10
(Bleq happy_var_1 happy_var_3
)
happyReduction_13 _ _ _ = notHappyAtAll
happyNewToken action sts stk [] =
action 25 25 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 {
While _ -> cont 11;
Do _ -> cont 12;
BracketOpen _ -> cont 13;
BracketClose _ -> cont 14;
ParensOpen _ -> cont 15;
ParensClose _ -> cont 16;
Semicolon _ -> cont 17;
Assign _ -> cont 18;
Sym _ happy_dollar_dollar -> cont 19;
Var _ happy_dollar_dollar -> cont 20;
Int _ happy_dollar_dollar -> cont 21;
TLT _ -> cont 22;
TGT _ -> cont 23;
TAND _ -> cont 24;
_ -> happyError' (tk:tks)
}
happyError_ 25 tk tks = happyError' tks
happyError_ _ tk tks = happyError' (tk:tks)
newtype HappyIdentity a = HappyIdentity a
happyIdentity = HappyIdentity
happyRunIdentity (HappyIdentity a) = a
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 . parseError
parser tks = happyRunIdentity happySomeParser where
happySomeParser = happyThen (happyParse action_0 tks) (\x -> case x of {HappyAbsSyn4 z -> happyReturn z; _other -> notHappyAtAll })
happySeq = happyDontSeq
parseError :: [Token] -> a
parseError _ = error "Parse error"
{-# LINE 1 "templates/GenericTemplate.hs" #-}
{-# LINE 1 "templates/GenericTemplate.hs" #-}
{-# LINE 1 "<built-in>" #-}
{-# LINE 1 "<command-line>" #-}
{-# LINE 1 "templates/GenericTemplate.hs" #-}
-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp
{-# LINE 30 "templates/GenericTemplate.hs" #-}
{-# LINE 51 "templates/GenericTemplate.hs" #-}
{-# LINE 61 "templates/GenericTemplate.hs" #-}
{-# LINE 70 "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 148 "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 =
happyThen1 (fn stk tk) (\r -> action nt j tk st1 sts1 (r `HappyStk` drop_stk))
where (sts1@(((st1@(HappyState (action))):(_)))) = happyDrop k ((st):(sts))
drop_stk = happyDropStk k 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 =
happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))
where (sts1@(((st1@(HappyState (action))):(_)))) = happyDrop k ((st):(sts))
drop_stk = happyDropStk k stk
new_state = action
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 246 "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 312 "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.