camfort-0.901: src/Camfort/Specification/Stencils/Grammar.hs
{-# OPTIONS_GHC -w #-}
-- -*- Mode: Haskell -*-
{-# LANGUAGE DeriveDataTypeable, PatternGuards #-}
module Camfort.Specification.Stencils.Grammar
( specParser, Specification(..), Region(..), Spec(..), Mod(..), lexer ) where
import Data.Char (isLetter, isNumber, isAlphaNum, toLower, isAlpha, isSpace)
import Data.List (intersect, sort, isPrefixOf)
import Data.Data
import Debug.Trace
import Camfort.Analysis.CommentAnnotator
import Camfort.Specification.Stencils.Syntax (showL)
import Control.Applicative(Applicative(..))
import Control.Monad (ap)
-- parser produced by Happy Version 1.19.5
data HappyAbsSyn
= HappyTerminal (Token)
| HappyErrorToken Int
| HappyAbsSyn4 (Specification)
| HappyAbsSyn5 ((String, Region))
| HappyAbsSyn6 (Region)
| HappyAbsSyn7 ((Depth Int, Dim Int, Bool))
| HappyAbsSyn8 ((Dim Int, Bool))
| HappyAbsSyn9 ((Depth Int, Bool))
| HappyAbsSyn10 (Depth Int)
| HappyAbsSyn11 (Dim Int)
| HappyAbsSyn12 (Bool)
| HappyAbsSyn13 (Spec)
| HappyAbsSyn14 (Mod)
| HappyAbsSyn15 ([Mod])
| HappyAbsSyn17 ([String])
{- to allow type-synonyms as our monads (likely
- with explicitly-specified bind and return)
- in Haskell98, it seems that with
- /type M a = .../, then /(HappyReduction M)/
- is not allowed. But Happy is a
- code-generator that can just substitute it.
type HappyReduction m =
Int
-> (Token)
-> HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> m HappyAbsSyn)
-> [HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> m HappyAbsSyn)]
-> HappyStk HappyAbsSyn
-> [(Token)] -> m HappyAbsSyn
-}
action_0,
action_1,
action_2,
action_3,
action_4,
action_5,
action_6,
action_7,
action_8,
action_9,
action_10,
action_11,
action_12,
action_13,
action_14,
action_15,
action_16,
action_17,
action_18,
action_19,
action_20,
action_21,
action_22,
action_23,
action_24,
action_25,
action_26,
action_27,
action_28,
action_29,
action_30,
action_31,
action_32,
action_33,
action_34,
action_35,
action_36,
action_37,
action_38,
action_39,
action_40,
action_41,
action_42,
action_43,
action_44,
action_45,
action_46,
action_47,
action_48,
action_49,
action_50,
action_51,
action_52,
action_53,
action_54,
action_55,
action_56,
action_57,
action_58,
action_59,
action_60,
action_61,
action_62,
action_63,
action_64,
action_65,
action_66,
action_67,
action_68,
action_69,
action_70,
action_71,
action_72,
action_73,
action_74,
action_75,
action_76,
action_77,
action_78,
action_79,
action_80,
action_81,
action_82 :: () => Int -> ({-HappyReduction (Either AnnotationParseError) = -}
Int
-> (Token)
-> HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> (Either AnnotationParseError) HappyAbsSyn)
-> [HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> (Either AnnotationParseError) HappyAbsSyn)]
-> HappyStk HappyAbsSyn
-> [(Token)] -> (Either AnnotationParseError) HappyAbsSyn)
happyReduce_1,
happyReduce_2,
happyReduce_3,
happyReduce_4,
happyReduce_5,
happyReduce_6,
happyReduce_7,
happyReduce_8,
happyReduce_9,
happyReduce_10,
happyReduce_11,
happyReduce_12,
happyReduce_13,
happyReduce_14,
happyReduce_15,
happyReduce_16,
happyReduce_17,
happyReduce_18,
happyReduce_19,
happyReduce_20,
happyReduce_21,
happyReduce_22,
happyReduce_23,
happyReduce_24,
happyReduce_25,
happyReduce_26,
happyReduce_27,
happyReduce_28,
happyReduce_29,
happyReduce_30,
happyReduce_31,
happyReduce_32,
happyReduce_33,
happyReduce_34,
happyReduce_35,
happyReduce_36,
happyReduce_37 :: () => ({-HappyReduction (Either AnnotationParseError) = -}
Int
-> (Token)
-> HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> (Either AnnotationParseError) HappyAbsSyn)
-> [HappyState (Token) (HappyStk HappyAbsSyn -> [(Token)] -> (Either AnnotationParseError) HappyAbsSyn)]
-> HappyStk HappyAbsSyn
-> [(Token)] -> (Either AnnotationParseError) HappyAbsSyn)
action_0 (18) = happyShift action_5
action_0 (19) = happyShift action_3
action_0 (4) = happyGoto action_4
action_0 (5) = happyGoto action_2
action_0 _ = happyFail
action_1 (19) = happyShift action_3
action_1 (5) = happyGoto action_2
action_1 _ = happyFail
action_2 _ = happyReduce_1
action_3 (36) = happyShift action_21
action_3 _ = happyFail
action_4 (40) = happyAccept
action_4 _ = happyFail
action_5 (20) = happyShift action_11
action_5 (21) = happyShift action_12
action_5 (23) = happyShift action_13
action_5 (24) = happyShift action_14
action_5 (27) = happyShift action_15
action_5 (28) = happyShift action_16
action_5 (29) = happyShift action_17
action_5 (30) = happyShift action_18
action_5 (32) = happyShift action_19
action_5 (38) = happyShift action_20
action_5 (6) = happyGoto action_6
action_5 (13) = happyGoto action_7
action_5 (14) = happyGoto action_8
action_5 (15) = happyGoto action_9
action_5 (16) = happyGoto action_10
action_5 _ = happyFail
action_6 (34) = happyShift action_35
action_6 (35) = happyShift action_36
action_6 _ = happyReduce_30
action_7 (36) = happyShift action_34
action_7 _ = happyFail
action_8 (21) = happyShift action_12
action_8 (27) = happyShift action_15
action_8 (28) = happyShift action_16
action_8 (29) = happyShift action_17
action_8 (32) = happyShift action_19
action_8 (38) = happyShift action_20
action_8 (6) = happyGoto action_33
action_8 _ = happyFail
action_9 (20) = happyShift action_11
action_9 (14) = happyGoto action_32
action_9 _ = happyFail
action_10 (21) = happyShift action_12
action_10 (23) = happyShift action_13
action_10 (24) = happyShift action_14
action_10 (27) = happyShift action_15
action_10 (28) = happyShift action_16
action_10 (29) = happyShift action_17
action_10 (32) = happyShift action_19
action_10 (38) = happyShift action_20
action_10 (6) = happyGoto action_29
action_10 (15) = happyGoto action_30
action_10 (16) = happyGoto action_31
action_10 _ = happyReduce_33
action_11 _ = happyReduce_31
action_12 (38) = happyShift action_28
action_12 _ = happyFail
action_13 _ = happyReduce_34
action_14 _ = happyReduce_35
action_15 (38) = happyShift action_27
action_15 _ = happyFail
action_16 (38) = happyShift action_26
action_16 _ = happyFail
action_17 (38) = happyShift action_25
action_17 _ = happyFail
action_18 (38) = happyShift action_24
action_18 _ = happyFail
action_19 _ = happyReduce_11
action_20 (21) = happyShift action_12
action_20 (27) = happyShift action_15
action_20 (28) = happyShift action_16
action_20 (29) = happyShift action_17
action_20 (32) = happyShift action_19
action_20 (38) = happyShift action_20
action_20 (6) = happyGoto action_23
action_20 _ = happyFail
action_21 (32) = happyShift action_22
action_21 _ = happyFail
action_22 (37) = happyShift action_54
action_22 _ = happyFail
action_23 (34) = happyShift action_35
action_23 (35) = happyShift action_36
action_23 (39) = happyShift action_53
action_23 _ = happyFail
action_24 (32) = happyShift action_40
action_24 (17) = happyGoto action_52
action_24 _ = happyFail
action_25 (22) = happyShift action_47
action_25 (25) = happyShift action_48
action_25 (26) = happyShift action_49
action_25 (7) = happyGoto action_51
action_25 (10) = happyGoto action_44
action_25 (11) = happyGoto action_45
action_25 (12) = happyGoto action_46
action_25 _ = happyFail
action_26 (22) = happyShift action_47
action_26 (25) = happyShift action_48
action_26 (26) = happyShift action_49
action_26 (7) = happyGoto action_50
action_26 (10) = happyGoto action_44
action_26 (11) = happyGoto action_45
action_26 (12) = happyGoto action_46
action_26 _ = happyFail
action_27 (22) = happyShift action_47
action_27 (25) = happyShift action_48
action_27 (26) = happyShift action_49
action_27 (7) = happyGoto action_43
action_27 (10) = happyGoto action_44
action_27 (11) = happyGoto action_45
action_27 (12) = happyGoto action_46
action_27 _ = happyFail
action_28 (25) = happyShift action_42
action_28 _ = happyFail
action_29 (34) = happyShift action_35
action_29 (35) = happyShift action_36
action_29 _ = happyReduce_29
action_30 _ = happyReduce_32
action_31 (23) = happyShift action_13
action_31 (24) = happyShift action_14
action_31 (15) = happyGoto action_30
action_31 (16) = happyGoto action_31
action_31 _ = happyReduce_33
action_32 (21) = happyShift action_12
action_32 (27) = happyShift action_15
action_32 (28) = happyShift action_16
action_32 (29) = happyShift action_17
action_32 (32) = happyShift action_19
action_32 (38) = happyShift action_20
action_32 (6) = happyGoto action_41
action_32 _ = happyFail
action_33 (34) = happyShift action_35
action_33 (35) = happyShift action_36
action_33 _ = happyReduce_28
action_34 (32) = happyShift action_40
action_34 (17) = happyGoto action_39
action_34 _ = happyFail
action_35 (21) = happyShift action_12
action_35 (27) = happyShift action_15
action_35 (28) = happyShift action_16
action_35 (29) = happyShift action_17
action_35 (32) = happyShift action_19
action_35 (38) = happyShift action_20
action_35 (6) = happyGoto action_38
action_35 _ = happyFail
action_36 (21) = happyShift action_12
action_36 (27) = happyShift action_15
action_36 (28) = happyShift action_16
action_36 (29) = happyShift action_17
action_36 (32) = happyShift action_19
action_36 (38) = happyShift action_20
action_36 (6) = happyGoto action_37
action_36 _ = happyFail
action_37 _ = happyReduce_9
action_38 (35) = happyShift action_36
action_38 _ = happyReduce_8
action_39 _ = happyReduce_2
action_40 (32) = happyShift action_40
action_40 (17) = happyGoto action_71
action_40 _ = happyReduce_37
action_41 (34) = happyShift action_35
action_41 (35) = happyShift action_36
action_41 _ = happyReduce_27
action_42 (37) = happyShift action_70
action_42 _ = happyFail
action_43 (39) = happyShift action_69
action_43 _ = happyFail
action_44 (22) = happyShift action_47
action_44 (25) = happyShift action_48
action_44 (8) = happyGoto action_66
action_44 (11) = happyGoto action_67
action_44 (12) = happyGoto action_68
action_44 _ = happyFail
action_45 (22) = happyShift action_47
action_45 (26) = happyShift action_49
action_45 (9) = happyGoto action_63
action_45 (10) = happyGoto action_64
action_45 (12) = happyGoto action_65
action_45 _ = happyFail
action_46 (25) = happyShift action_48
action_46 (26) = happyShift action_49
action_46 (10) = happyGoto action_61
action_46 (11) = happyGoto action_62
action_46 _ = happyFail
action_47 _ = happyReduce_24
action_48 (37) = happyShift action_60
action_48 _ = happyFail
action_49 (37) = happyShift action_59
action_49 _ = happyFail
action_50 (39) = happyShift action_58
action_50 _ = happyFail
action_51 (39) = happyShift action_57
action_51 _ = happyFail
action_52 (39) = happyShift action_56
action_52 _ = happyFail
action_53 _ = happyReduce_10
action_54 (21) = happyShift action_12
action_54 (27) = happyShift action_15
action_54 (28) = happyShift action_16
action_54 (29) = happyShift action_17
action_54 (32) = happyShift action_19
action_54 (38) = happyShift action_20
action_54 (6) = happyGoto action_55
action_54 _ = happyFail
action_55 (34) = happyShift action_35
action_55 (35) = happyShift action_36
action_55 _ = happyReduce_3
action_56 (31) = happyShift action_81
action_56 _ = happyReduce_25
action_57 _ = happyReduce_6
action_58 _ = happyReduce_5
action_59 (33) = happyShift action_80
action_59 _ = happyFail
action_60 (33) = happyShift action_79
action_60 _ = happyFail
action_61 (25) = happyShift action_48
action_61 (11) = happyGoto action_78
action_61 _ = happyFail
action_62 (26) = happyShift action_49
action_62 (10) = happyGoto action_77
action_62 _ = happyFail
action_63 _ = happyReduce_13
action_64 (22) = happyShift action_47
action_64 (12) = happyGoto action_76
action_64 _ = happyReduce_21
action_65 (26) = happyShift action_49
action_65 (10) = happyGoto action_75
action_65 _ = happyFail
action_66 _ = happyReduce_12
action_67 (22) = happyShift action_47
action_67 (12) = happyGoto action_74
action_67 _ = happyReduce_18
action_68 (25) = happyShift action_48
action_68 (11) = happyGoto action_73
action_68 _ = happyFail
action_69 _ = happyReduce_4
action_70 (33) = happyShift action_72
action_70 _ = happyFail
action_71 _ = happyReduce_36
action_72 (39) = happyShift action_82
action_72 _ = happyFail
action_73 _ = happyReduce_16
action_74 _ = happyReduce_17
action_75 _ = happyReduce_20
action_76 _ = happyReduce_19
action_77 _ = happyReduce_15
action_78 _ = happyReduce_14
action_79 _ = happyReduce_23
action_80 _ = happyReduce_22
action_81 _ = happyReduce_26
action_82 _ = happyReduce_7
happyReduce_1 = happySpecReduce_1 4 happyReduction_1
happyReduction_1 (HappyAbsSyn5 happy_var_1)
= HappyAbsSyn4
(RegionDec (fst happy_var_1) (snd happy_var_1)
)
happyReduction_1 _ = notHappyAtAll
happyReduce_2 = happyReduce 4 4 happyReduction_2
happyReduction_2 ((HappyAbsSyn17 happy_var_4) `HappyStk`
_ `HappyStk`
(HappyAbsSyn13 happy_var_2) `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn4
(SpecDec happy_var_2 happy_var_4
) `HappyStk` happyRest
happyReduce_3 = happyReduce 5 5 happyReduction_3
happyReduction_3 ((HappyAbsSyn6 happy_var_5) `HappyStk`
_ `HappyStk`
(HappyTerminal (TId happy_var_3)) `HappyStk`
_ `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn5
((happy_var_3, happy_var_5)
) `HappyStk` happyRest
happyReduce_4 = happyReduce 4 6 happyReduction_4
happyReduction_4 (_ `HappyStk`
(HappyAbsSyn7 happy_var_3) `HappyStk`
_ `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn6
(applyAttr Forward happy_var_3
) `HappyStk` happyRest
happyReduce_5 = happyReduce 4 6 happyReduction_5
happyReduction_5 (_ `HappyStk`
(HappyAbsSyn7 happy_var_3) `HappyStk`
_ `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn6
(applyAttr Backward happy_var_3
) `HappyStk` happyRest
happyReduce_6 = happyReduce 4 6 happyReduction_6
happyReduction_6 (_ `HappyStk`
(HappyAbsSyn7 happy_var_3) `HappyStk`
_ `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn6
(applyAttr Centered happy_var_3
) `HappyStk` happyRest
happyReduce_7 = happyReduce 6 6 happyReduction_7
happyReduction_7 (_ `HappyStk`
(HappyTerminal (TNum happy_var_5)) `HappyStk`
_ `HappyStk`
_ `HappyStk`
_ `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn6
(Centered 0 (read happy_var_5) True
) `HappyStk` happyRest
happyReduce_8 = happySpecReduce_3 6 happyReduction_8
happyReduction_8 (HappyAbsSyn6 happy_var_3)
_
(HappyAbsSyn6 happy_var_1)
= HappyAbsSyn6
(Or happy_var_1 happy_var_3
)
happyReduction_8 _ _ _ = notHappyAtAll
happyReduce_9 = happySpecReduce_3 6 happyReduction_9
happyReduction_9 (HappyAbsSyn6 happy_var_3)
_
(HappyAbsSyn6 happy_var_1)
= HappyAbsSyn6
(And happy_var_1 happy_var_3
)
happyReduction_9 _ _ _ = notHappyAtAll
happyReduce_10 = happySpecReduce_3 6 happyReduction_10
happyReduction_10 _
(HappyAbsSyn6 happy_var_2)
_
= HappyAbsSyn6
(happy_var_2
)
happyReduction_10 _ _ _ = notHappyAtAll
happyReduce_11 = happySpecReduce_1 6 happyReduction_11
happyReduction_11 (HappyTerminal (TId happy_var_1))
= HappyAbsSyn6
(Var happy_var_1
)
happyReduction_11 _ = notHappyAtAll
happyReduce_12 = happySpecReduce_2 7 happyReduction_12
happyReduction_12 (HappyAbsSyn8 happy_var_2)
(HappyAbsSyn10 happy_var_1)
= HappyAbsSyn7
((happy_var_1, fst happy_var_2, snd happy_var_2)
)
happyReduction_12 _ _ = notHappyAtAll
happyReduce_13 = happySpecReduce_2 7 happyReduction_13
happyReduction_13 (HappyAbsSyn9 happy_var_2)
(HappyAbsSyn11 happy_var_1)
= HappyAbsSyn7
((fst happy_var_2, happy_var_1, snd happy_var_2)
)
happyReduction_13 _ _ = notHappyAtAll
happyReduce_14 = happySpecReduce_3 7 happyReduction_14
happyReduction_14 (HappyAbsSyn11 happy_var_3)
(HappyAbsSyn10 happy_var_2)
(HappyAbsSyn12 happy_var_1)
= HappyAbsSyn7
((happy_var_2, happy_var_3, happy_var_1)
)
happyReduction_14 _ _ _ = notHappyAtAll
happyReduce_15 = happySpecReduce_3 7 happyReduction_15
happyReduction_15 (HappyAbsSyn10 happy_var_3)
(HappyAbsSyn11 happy_var_2)
(HappyAbsSyn12 happy_var_1)
= HappyAbsSyn7
((happy_var_3, happy_var_2, happy_var_1)
)
happyReduction_15 _ _ _ = notHappyAtAll
happyReduce_16 = happySpecReduce_2 8 happyReduction_16
happyReduction_16 (HappyAbsSyn11 happy_var_2)
(HappyAbsSyn12 happy_var_1)
= HappyAbsSyn8
((happy_var_2, happy_var_1)
)
happyReduction_16 _ _ = notHappyAtAll
happyReduce_17 = happySpecReduce_2 8 happyReduction_17
happyReduction_17 (HappyAbsSyn12 happy_var_2)
(HappyAbsSyn11 happy_var_1)
= HappyAbsSyn8
((happy_var_1, happy_var_2)
)
happyReduction_17 _ _ = notHappyAtAll
happyReduce_18 = happySpecReduce_1 8 happyReduction_18
happyReduction_18 (HappyAbsSyn11 happy_var_1)
= HappyAbsSyn8
((happy_var_1, True)
)
happyReduction_18 _ = notHappyAtAll
happyReduce_19 = happySpecReduce_2 9 happyReduction_19
happyReduction_19 (HappyAbsSyn12 happy_var_2)
(HappyAbsSyn10 happy_var_1)
= HappyAbsSyn9
((happy_var_1, happy_var_2)
)
happyReduction_19 _ _ = notHappyAtAll
happyReduce_20 = happySpecReduce_2 9 happyReduction_20
happyReduction_20 (HappyAbsSyn10 happy_var_2)
(HappyAbsSyn12 happy_var_1)
= HappyAbsSyn9
((happy_var_2, happy_var_1)
)
happyReduction_20 _ _ = notHappyAtAll
happyReduce_21 = happySpecReduce_1 9 happyReduction_21
happyReduction_21 (HappyAbsSyn10 happy_var_1)
= HappyAbsSyn9
((happy_var_1, True)
)
happyReduction_21 _ = notHappyAtAll
happyReduce_22 = happySpecReduce_3 10 happyReduction_22
happyReduction_22 (HappyTerminal (TNum happy_var_3))
_
_
= HappyAbsSyn10
(Depth $ read happy_var_3
)
happyReduction_22 _ _ _ = notHappyAtAll
happyReduce_23 = happySpecReduce_3 11 happyReduction_23
happyReduction_23 (HappyTerminal (TNum happy_var_3))
_
_
= HappyAbsSyn11
(Dim $ read happy_var_3
)
happyReduction_23 _ _ _ = notHappyAtAll
happyReduce_24 = happySpecReduce_1 12 happyReduction_24
happyReduction_24 _
= HappyAbsSyn12
(False
)
happyReduce_25 = happyReduce 4 13 happyReduction_25
happyReduction_25 (_ `HappyStk`
(HappyAbsSyn17 happy_var_3) `HappyStk`
_ `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn13
(Temporal happy_var_3 False
) `HappyStk` happyRest
happyReduce_26 = happyReduce 5 13 happyReduction_26
happyReduction_26 (_ `HappyStk`
_ `HappyStk`
(HappyAbsSyn17 happy_var_3) `HappyStk`
_ `HappyStk`
_ `HappyStk`
happyRest)
= HappyAbsSyn13
(Temporal happy_var_3 True
) `HappyStk` happyRest
happyReduce_27 = happySpecReduce_3 13 happyReduction_27
happyReduction_27 (HappyAbsSyn6 happy_var_3)
(HappyAbsSyn14 happy_var_2)
(HappyAbsSyn15 happy_var_1)
= HappyAbsSyn13
(Spatial (happy_var_1 ++ [happy_var_2]) happy_var_3
)
happyReduction_27 _ _ _ = notHappyAtAll
happyReduce_28 = happySpecReduce_2 13 happyReduction_28
happyReduction_28 (HappyAbsSyn6 happy_var_2)
(HappyAbsSyn14 happy_var_1)
= HappyAbsSyn13
(Spatial [happy_var_1] happy_var_2
)
happyReduction_28 _ _ = notHappyAtAll
happyReduce_29 = happySpecReduce_2 13 happyReduction_29
happyReduction_29 (HappyAbsSyn6 happy_var_2)
(HappyAbsSyn14 happy_var_1)
= HappyAbsSyn13
(Spatial [happy_var_1] happy_var_2
)
happyReduction_29 _ _ = notHappyAtAll
happyReduce_30 = happySpecReduce_1 13 happyReduction_30
happyReduction_30 (HappyAbsSyn6 happy_var_1)
= HappyAbsSyn13
(Spatial [] happy_var_1
)
happyReduction_30 _ = notHappyAtAll
happyReduce_31 = happySpecReduce_1 14 happyReduction_31
happyReduction_31 _
= HappyAbsSyn14
(ReadOnce
)
happyReduce_32 = happySpecReduce_2 15 happyReduction_32
happyReduction_32 (HappyAbsSyn15 happy_var_2)
(HappyAbsSyn14 happy_var_1)
= HappyAbsSyn15
(happy_var_1 : happy_var_2
)
happyReduction_32 _ _ = notHappyAtAll
happyReduce_33 = happySpecReduce_1 15 happyReduction_33
happyReduction_33 (HappyAbsSyn14 happy_var_1)
= HappyAbsSyn15
([happy_var_1]
)
happyReduction_33 _ = notHappyAtAll
happyReduce_34 = happySpecReduce_1 16 happyReduction_34
happyReduction_34 _
= HappyAbsSyn14
(AtMost
)
happyReduce_35 = happySpecReduce_1 16 happyReduction_35
happyReduction_35 _
= HappyAbsSyn14
(AtLeast
)
happyReduce_36 = happySpecReduce_2 17 happyReduction_36
happyReduction_36 (HappyAbsSyn17 happy_var_2)
(HappyTerminal (TId happy_var_1))
= HappyAbsSyn17
(happy_var_1 : happy_var_2
)
happyReduction_36 _ _ = notHappyAtAll
happyReduce_37 = happySpecReduce_1 17 happyReduction_37
happyReduction_37 (HappyTerminal (TId happy_var_1))
= HappyAbsSyn17
([happy_var_1]
)
happyReduction_37 _ = notHappyAtAll
happyNewToken action sts stk [] =
action 40 40 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 {
TId "stencil" -> cont 18;
TId "region" -> cont 19;
TId "readonce" -> cont 20;
TId "reflexive" -> cont 21;
TId "irreflexive" -> cont 22;
TId "atmost" -> cont 23;
TId "atleast" -> cont 24;
TId "dim" -> cont 25;
TId "depth" -> cont 26;
TId "forward" -> cont 27;
TId "backward" -> cont 28;
TId "centered" -> cont 29;
TId "dependency" -> cont 30;
TId "mutual" -> cont 31;
TId happy_dollar_dollar -> cont 32;
TNum happy_dollar_dollar -> cont 33;
TPlus -> cont 34;
TStar -> cont 35;
TDoubleColon -> cont 36;
TEqual -> cont 37;
TLParen -> cont 38;
TRParen -> cont 39;
_ -> happyError' (tk:tks)
}
happyError_ 40 tk tks = happyError' tks
happyError_ _ tk tks = happyError' (tk:tks)
happyThen :: () => Either AnnotationParseError a -> (a -> Either AnnotationParseError b) -> Either AnnotationParseError b
happyThen = (>>=)
happyReturn :: () => a -> Either AnnotationParseError a
happyReturn = (return)
happyThen1 m k tks = (>>=) m (\a -> k a tks)
happyReturn1 :: () => a -> b -> Either AnnotationParseError a
happyReturn1 = \a tks -> (return) a
happyError' :: () => [(Token)] -> Either AnnotationParseError a
happyError' = happyError
parseSpec tks = happySomeParser where
happySomeParser = happyThen (happyParse action_0 tks) (\x -> case x of {HappyAbsSyn4 z -> happyReturn z; _other -> notHappyAtAll })
happySeq = happyDontSeq
newtype Depth a = Depth a
newtype Dim a = Dim a
applyAttr :: (Int -> Int -> Bool -> Region)
-> (Depth Int, Dim Int, Bool)
-> Region
applyAttr constr (Depth d, Dim dim, irrefl) = constr d dim irrefl
data Specification
= RegionDec String Region
| SpecDec Spec [String]
deriving (Show, Eq, Ord, Typeable, Data)
data Region
= Forward Int Int Bool
| Backward Int Int Bool
| Centered Int Int Bool
| Or Region Region
| And Region Region
| Var String
deriving (Show, Eq, Ord, Typeable, Data)
data Spec
= Spatial [Mod] Region
| Temporal [String] Bool
deriving (Show, Eq, Ord, Typeable, Data)
data Mod
= AtLeast
| AtMost
| ReadOnce
deriving (Show, Eq, Ord, Typeable, Data)
--------------------------------------------------
data Token
= TDoubleColon
| TStar
| TPlus
| TEqual
| TComma
| TLParen
| TRParen
| TId String
| TNum String
deriving (Show)
addToTokens :: Token -> String -> Either AnnotationParseError [ Token ]
addToTokens tok rest = do
tokens <- lexer' rest
return $ tok : tokens
stripLeadingWhiteSpace (' ':xs) = stripLeadingWhiteSpace xs
stripLeadingWhiteSpace ('\t':xs) = stripLeadingWhiteSpace xs
stripLeadingWhiteSpace ('\n':xs) = stripLeadingWhiteSpace xs
stripLeadingWhiteSpace xs = xs
lexer :: String -> Either AnnotationParseError [ Token ]
lexer input | length (stripLeadingWhiteSpace input) >= 2 =
case stripLeadingWhiteSpace input of
-- Check the leading character is '=' for specification
'=':input' ->
-- First test to see if the input looks like an actual
-- specification of either a stencil or region
if (input' `hasPrefix` "stencil" || input' `hasPrefix` "region")
then lexer' input'
else Left NotAnnotation
_ -> Left NotAnnotation
where
hasPrefix [] str = False
hasPrefix (' ':xs) str = hasPrefix xs str
hasPrefix xs str = isPrefixOf str xs
lexer _ = Left NotAnnotation
lexer' :: String -> Either AnnotationParseError [ Token ]
lexer' [] = return []
lexer' (' ':xs) = lexer' xs
lexer' ('\t':xs) = lexer' xs
lexer' (':':':':xs) = addToTokens TDoubleColon xs
lexer' ('*':xs) = addToTokens TStar xs
lexer' ('+':xs) = addToTokens TPlus xs
lexer' ('=':xs) = addToTokens TEqual xs
-- Comma hack: drop commas that are not separating numbers, in order to avoid need for 2-token lookahead.
lexer' (',':xs)
| x':xs' <- dropWhile isSpace xs, not (isNumber x') = lexer' (x':xs')
| otherwise = addToTokens TComma xs
lexer' ('(':xs) = addToTokens TLParen xs
lexer' (')':xs) = addToTokens TRParen xs
lexer' (x:xs)
| isLetter x = aux TId $ \ c -> isAlphaNum c || c == '_'
| isNumber x = aux TNum isNumber
| otherwise
= failWith $ "Not an indentifier " ++ show x
where
aux f p = (f target :) `fmap` lexer' rest
where (target, rest) = span p (x:xs)
lexer' x
= failWith $ "Not a valid piece of stencil syntax " ++ show x
--------------------------------------------------
-- specParser :: String -> Either AnnotationParseError Specification
specParser :: AnnotationParser Specification
specParser src = do
tokens <- lexer src
parseSpec tokens >>= modValidate
-- Check whether modifiers are used correctly
modValidate :: Specification -> Either AnnotationParseError Specification
modValidate (SpecDec (Spatial mods r) vars) =
do mods' <- modValidate' $ sort mods
return $ SpecDec (Spatial mods' r) vars
where modValidate' [] = return $ []
modValidate' (AtLeast : AtLeast : xs)
= failWith "Duplicate 'atLeast' modifier; use at most one."
modValidate' (AtMost : AtMost : xs)
= failWith "Duplicate 'atMost' modifier; use at most one."
modValidate' (ReadOnce : ReadOnce : xs)
= failWith "Duplicate 'readOnce' modifier; use at most one."
modValidate' (AtLeast : AtMost : xs)
= failWith $ "Conflicting modifiers: cannot use 'atLeast' and "
++ "'atMost' together"
modValidate' (x : xs)
= do xs' <- modValidate' xs
return $ x : xs'
modValidate x = return x
happyError :: [ Token ] -> Either AnnotationParseError a
happyError t = failWith $ "Could not parse specification at: " ++ show t
{-# LINE 1 "templates/GenericTemplate.hs" #-}
{-# LINE 1 "templates/GenericTemplate.hs" #-}
{-# LINE 1 "<built-in>" #-}
{-# LINE 16 "<built-in>" #-}
{-# LINE 1 "/usr/local/lib/ghc-7.10.2/include/ghcversion.h" #-}
{-# LINE 17 "<built-in>" #-}
{-# 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" #-}
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
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.
{-# 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.