GrammarParser.y

-- Generated by RTK from grammar 'Grammar'. Do not edit by hand.
{
{-# LANGUAGE DeriveDataTypeable #-}
module GrammarParser where
import qualified Data.Generics as Gen
import qualified GrammarLexer as L (Token(..), PosToken(..), AlexPosn(..), alexScanTokens)
}

%name parseGrammar
%tokentype { L.PosToken }
%monad { Either String }
%error { parseError }

%token

rtk__eof { L.PosToken _ L.EndOfFile }
tok_Clause_dummy_10 { L.PosToken _ L.Tk__tok_Clause_dummy_10 }
tok_Grammar_dummy_11 { L.PosToken _ L.Tk__tok_Grammar_dummy_11 }
tok_IdList_dummy_9 { L.PosToken _ L.Tk__tok_IdList_dummy_9 }
tok_Name_dummy_8 { L.PosToken _ L.Tk__tok_Name_dummy_8 }
tok_Option_dummy_7 { L.PosToken _ L.Tk__tok_Option_dummy_7 }
tok_OptionList_dummy_6 { L.PosToken _ L.Tk__tok_OptionList_dummy_6 }
tok_Rule_dummy_5 { L.PosToken _ L.Tk__tok_Rule_dummy_5 }
tok_RuleList_dummy_4 { L.PosToken _ L.Tk__tok_RuleList_dummy_4 }
tok_StrLit_dummy_3 { L.PosToken _ L.Tk__tok_StrLit_dummy_3 }
tok__tilde__14 { L.PosToken _ L.Tk__tok__tilde__14 }
tok__pipe__11 { L.PosToken _ L.Tk__tok__pipe__11 }
tok_imports_2 { L.PosToken _ L.Tk__tok_imports_2 }
tok_grammar_0 { L.PosToken _ L.Tk__tok_grammar_0 }
tok__symbol_symmacro_9 { L.PosToken _ L.Tk__tok__symbol_symmacro_9 }
tok__symbol_shortcuts_6 { L.PosToken _ L.Tk__tok__symbol_shortcuts_6 }
tok__symbol__16 { L.PosToken _ L.Tk__tok__symbol__16 }
tok__eql__3 { L.PosToken _ L.Tk__tok__eql__3 }
tok__semi__1 { L.PosToken _ L.Tk__tok__semi__1 }
tok__colon__4 { L.PosToken _ L.Tk__tok__colon__4 }
tok__dot__5 { L.PosToken _ L.Tk__tok__dot__5 }
tok__coma__10 { L.PosToken _ L.Tk__tok__coma__10 }
tok__plus__15 { L.PosToken _ L.Tk__tok__plus__15 }
tok__star__13 { L.PosToken _ L.Tk__tok__star__13 }
tok__rparen__8 { L.PosToken _ L.Tk__tok__rparen__8 }
tok__lparen__7 { L.PosToken _ L.Tk__tok__lparen__7 }
tok__exclamation__12 { L.PosToken _ L.Tk__tok__exclamation__12 }
regexplit { L.PosToken _ (L.Tk__regexplit _) }
bigstr { L.PosToken _ (L.Tk__bigstr _) }
str { L.PosToken _ (L.Tk__str _) }
id { L.PosToken _ (L.Tk__id _) }
qq_Name { L.PosToken _ (L.Tk__qq_Name _) }
qq_StrLit { L.PosToken _ (L.Tk__qq_StrLit _) }
qq_Clause { L.PosToken _ (L.Tk__qq_Clause _) }
qq_IdList { L.PosToken _ (L.Tk__qq_IdList _) }
qq_Option { L.PosToken _ (L.Tk__qq_Option _) }
qq_OptionList { L.PosToken _ (L.Tk__qq_OptionList _) }
qq_Rule { L.PosToken _ (L.Tk__qq_Rule _) }
qq_RuleList { L.PosToken _ (L.Tk__qq_RuleList _) }
qq_Grammar { L.PosToken _ (L.Tk__qq_Grammar _) }

%%

Grammar__top : Grammar rtk__eof { $1 }

Grammar : tok_Grammar_dummy_11 Grammar tok_Grammar_dummy_11 { Ctr__Grammar__0 (rtkPosOf $1) $2 } |
          tok_Clause_dummy_10 Clause tok_Clause_dummy_10 { Ctr__Grammar__1 (rtkPosOf $1) $2 } |
          tok_IdList_dummy_9 IdList tok_IdList_dummy_9 { Ctr__Grammar__2 (rtkPosOf $1) (reverse $2) } |
          tok_Name_dummy_8 Name tok_Name_dummy_8 { Ctr__Grammar__3 (rtkPosOf $1) $2 } |
          tok_Option_dummy_7 Option tok_Option_dummy_7 { Ctr__Grammar__4 (rtkPosOf $1) $2 } |
          tok_OptionList_dummy_6 OptionList tok_OptionList_dummy_6 { Ctr__Grammar__5 (rtkPosOf $1) (reverse $2) } |
          tok_Rule_dummy_5 Rule tok_Rule_dummy_5 { Ctr__Grammar__6 (rtkPosOf $1) $2 } |
          tok_RuleList_dummy_4 RuleList tok_RuleList_dummy_4 { Ctr__Grammar__7 (rtkPosOf $1) (reverse $2) } |
          tok_StrLit_dummy_3 StrLit tok_StrLit_dummy_3 { Ctr__Grammar__8 (rtkPosOf $1) $2 }

Grammar : qq_Grammar { Anti_Grammar (tkVal_qq_Grammar $1) } |
          tok_grammar_0 StrLit tok__semi__1 RuleList { GrammarDef (rtkPosOf $1) $2 (reverse $4) } |
          tok_grammar_0 StrLit tok__semi__1 tok_imports_2 bigstr RuleList { GrammarImports (rtkPosOf $1) $2 (tkVal_bigstr $5) (reverse $6) }

Clause5 : qq_Clause { Anti_Clause (tkVal_qq_Clause $1) } |
          tok__lparen__7 Clause tok__rparen__8 { $2 } |
          Name { Ref (rtkPosOf $1) $1 } |
          StrLit { Lit (rtkPosOf $1) $1 } |
          tok__dot__5 { Dot (rtkPosOf $1) } |
          regexplit { Regex (rtkPosOf $1) (tkVal_regexplit $1) }

Clause4 : Clause5 tok__star__13 { Star (rtkPosOf $1) $1 } |
          Clause5 tok__star__13 tok__tilde__14 Clause5 { StarDelim (rtkPosOf $1) $1 $4 } |
          Clause5 tok__plus__15 { Plus (rtkPosOf $1) $1 } |
          Clause5 tok__plus__15 tok__tilde__14 Clause5 { PlusDelim (rtkPosOf $1) $1 $4 } |
          Clause5 tok__symbol__16 { Opt (rtkPosOf $1) $1 } |
          Clause5 { $1 }

Clause3 : tok__coma__10 Clause4 { Lifted (rtkPosOf $1) $2 } |
          tok__exclamation__12 Clause4 { Ignored (rtkPosOf $1) $2 } |
          Clause4 { $1 }

Clause2 : Clause2 Clause3 { Seq (rtkPosOf $1) $1 $2 } |
          Clause3 { $1 }

Clause1 : Name tok__colon__4 Clause2 { Labeled (rtkPosOf $1) $1 $3 } |
          Clause2 { $1 }

Clause : Clause tok__pipe__11 Clause1 { Alt (rtkPosOf $1) $1 $3 } |
         Clause1 { $1 }

IdList__plus_list_ : ListElem_IdList2 { [$1] } |
                     IdList__plus_list_ tok__coma__10 ListElem_IdList2 { $3 : $1 }

IdList : IdList__plus_list_ { $1 } |
         {- empty -} { [] }

Name : qq_Name { Anti_Name (tkVal_qq_Name $1) } |
       id { Ident (rtkPosOf $1) (tkVal_id $1) }

ListElem_IdList2 : qq_IdList { Anti_Name (tkVal_qq_IdList $1) } |
                   Name { $1 }

Option : qq_Option { Anti_Option (tkVal_qq_Option $1) } |
         tok__symbol_shortcuts_6 tok__lparen__7 IdList tok__rparen__8 { Shortcuts (rtkPosOf $1) (reverse $3) } |
         tok__symbol_symmacro_9 { Symmacro (rtkPosOf $1) }

ListElem_OptionList1 : qq_OptionList { Anti_Option (tkVal_qq_OptionList $1) } |
                       Option { $1 }

OptionList : ListElem_OptionList1 { [$1] } |
             OptionList ListElem_OptionList1 { $2 : $1 }

Rule1 : qq_Rule { Anti_Rule (tkVal_qq_Rule $1) } |
        Name tok__eql__3 Clause tok__semi__1 { RuleSimple (rtkPosOf $1) $1 $3 } |
        Name tok__colon__4 Name tok__eql__3 Clause tok__semi__1 { RuleTyped (rtkPosOf $1) $1 $3 $5 } |
        Name tok__dot__5 Name tok__colon__4 Name tok__eql__3 Clause tok__semi__1 { RuleTypedFunc (rtkPosOf $1) $1 $3 $5 $7 } |
        tok__dot__5 Name tok__colon__4 Name tok__eql__3 Clause tok__semi__1 { RuleFunc (rtkPosOf $1) $2 $4 $6 }

Rule : OptionList Rule1 { RuleWithOptions (rtkPosOf (reverse $1)) (reverse $1) $2 } |
       Rule1 { $1 }

ListElem_RuleList0 : qq_RuleList { Anti_Rule (tkVal_qq_RuleList $1) } |
                     Rule { $1 }

RuleList : {- empty -} { [] } |
           RuleList ListElem_RuleList0 { $2 : $1 }

StrLit : qq_StrLit { Anti_StrLit (tkVal_qq_StrLit $1) } |
         str { Str (rtkPosOf $1) (tkVal_str $1) }


{
parseError :: [L.PosToken] -> Either String a
parseError [] = Left "unexpected end of input"
parseError (L.PosToken (L.AlexPn _ line col) tok : _) =
    Left $ show line ++ ":" ++ show col ++ ":unexpected " ++ showRtkToken tok

-- Render a token the way it appears in the source, for error messages
showRtkToken :: L.Token -> String
showRtkToken L.EndOfFile = "end of input"
showRtkToken L.Tk__tok_Clause_dummy_10 = "'tok_Clause_dummy_10'"
showRtkToken L.Tk__tok_Grammar_dummy_11 = "'tok_Grammar_dummy_11'"
showRtkToken L.Tk__tok_IdList_dummy_9 = "'tok_IdList_dummy_9'"
showRtkToken L.Tk__tok_Name_dummy_8 = "'tok_Name_dummy_8'"
showRtkToken L.Tk__tok_Option_dummy_7 = "'tok_Option_dummy_7'"
showRtkToken L.Tk__tok_OptionList_dummy_6 = "'tok_OptionList_dummy_6'"
showRtkToken L.Tk__tok_Rule_dummy_5 = "'tok_Rule_dummy_5'"
showRtkToken L.Tk__tok_RuleList_dummy_4 = "'tok_RuleList_dummy_4'"
showRtkToken L.Tk__tok_StrLit_dummy_3 = "'tok_StrLit_dummy_3'"
showRtkToken L.Tk__tok__tilde__14 = "'~'"
showRtkToken L.Tk__tok__pipe__11 = "'|'"
showRtkToken L.Tk__tok_imports_2 = "'imports'"
showRtkToken L.Tk__tok_grammar_0 = "'grammar'"
showRtkToken L.Tk__tok__symbol_symmacro_9 = "'@symmacro'"
showRtkToken L.Tk__tok__symbol_shortcuts_6 = "'@shortcuts'"
showRtkToken L.Tk__tok__symbol__16 = "'?'"
showRtkToken L.Tk__tok__eql__3 = "'='"
showRtkToken L.Tk__tok__semi__1 = "';'"
showRtkToken L.Tk__tok__colon__4 = "':'"
showRtkToken L.Tk__tok__dot__5 = "'.'"
showRtkToken L.Tk__tok__coma__10 = "','"
showRtkToken L.Tk__tok__plus__15 = "'+'"
showRtkToken L.Tk__tok__star__13 = "'*'"
showRtkToken L.Tk__tok__rparen__8 = "')'"
showRtkToken L.Tk__tok__lparen__7 = "'('"
showRtkToken L.Tk__tok__exclamation__12 = "'!'"
showRtkToken (L.Tk__regexplit v) = "regexplit " ++ show v
showRtkToken (L.Tk__bigstr v) = "bigstr " ++ show v
showRtkToken (L.Tk__str v) = "str " ++ show v
showRtkToken (L.Tk__id v) = "id " ++ show v
showRtkToken (L.Tk__qq_Name v) = "qq_Name " ++ show v
showRtkToken (L.Tk__qq_StrLit v) = "qq_StrLit " ++ show v
showRtkToken (L.Tk__qq_Clause v) = "qq_Clause " ++ show v
showRtkToken (L.Tk__qq_IdList v) = "qq_IdList " ++ show v
showRtkToken (L.Tk__qq_Option v) = "qq_Option " ++ show v
showRtkToken (L.Tk__qq_OptionList v) = "qq_OptionList " ++ show v
showRtkToken (L.Tk__qq_Rule v) = "qq_Rule " ++ show v
showRtkToken (L.Tk__qq_RuleList v) = "qq_RuleList " ++ show v
showRtkToken (L.Tk__qq_Grammar v) = "qq_Grammar " ++ show v

-- Source position of a node: every constructor except the Anti_* splice
-- artifacts stores the position of its alternative's first symbol in its
-- first field. Positions are transparent for equality and ordering, so two
-- ASTs that differ only in source positions (e.g. a quasi-quote parsed at
-- compile time vs the same construct parsed at run time) compare equal.
newtype RtkPos = RtkPos L.AlexPosn deriving (Show, Gen.Data, Gen.Typeable)
instance Eq RtkPos where _ == _ = True
instance Ord RtkPos where compare _ _ = EQ

-- The position used where no source token exists: empty productions, empty
-- lists, absent optionals and Anti_* quasi-quote splices
rtkNoPos :: RtkPos
rtkNoPos = RtkPos (L.AlexPn 0 0 0)

class RtkPosOf a where
    rtkPosOf :: a -> RtkPos
instance RtkPosOf L.PosToken where
    rtkPosOf (L.PosToken p _) = RtkPos p
instance RtkPosOf a => RtkPosOf [a] where
    rtkPosOf (x : _) = rtkPosOf x
    rtkPosOf []      = rtkNoPos
instance RtkPosOf a => RtkPosOf (Maybe a) where
    rtkPosOf (Just x) = rtkPosOf x
    rtkPosOf Nothing  = rtkNoPos
-- A Char carries no position; this also covers String token payloads
instance RtkPosOf Char where
    rtkPosOf _ = rtkNoPos

-- Recover a token's payload from the whole positioned token: %token
-- bindings keep the L.PosToken so semantic actions can read its position
tkVal_regexplit :: L.PosToken -> String
tkVal_regexplit (L.PosToken _ (L.Tk__regexplit v)) = v
tkVal_regexplit t = error ("rtk internal error: token regexplit expected, got " ++ showRtkToken (L.ptToken t))
tkVal_bigstr :: L.PosToken -> String
tkVal_bigstr (L.PosToken _ (L.Tk__bigstr v)) = v
tkVal_bigstr t = error ("rtk internal error: token bigstr expected, got " ++ showRtkToken (L.ptToken t))
tkVal_str :: L.PosToken -> String
tkVal_str (L.PosToken _ (L.Tk__str v)) = v
tkVal_str t = error ("rtk internal error: token str expected, got " ++ showRtkToken (L.ptToken t))
tkVal_id :: L.PosToken -> String
tkVal_id (L.PosToken _ (L.Tk__id v)) = v
tkVal_id t = error ("rtk internal error: token id expected, got " ++ showRtkToken (L.ptToken t))
tkVal_qq_Name :: L.PosToken -> String
tkVal_qq_Name (L.PosToken _ (L.Tk__qq_Name v)) = v
tkVal_qq_Name t = error ("rtk internal error: token qq_Name expected, got " ++ showRtkToken (L.ptToken t))
tkVal_qq_StrLit :: L.PosToken -> String
tkVal_qq_StrLit (L.PosToken _ (L.Tk__qq_StrLit v)) = v
tkVal_qq_StrLit t = error ("rtk internal error: token qq_StrLit expected, got " ++ showRtkToken (L.ptToken t))
tkVal_qq_Clause :: L.PosToken -> String
tkVal_qq_Clause (L.PosToken _ (L.Tk__qq_Clause v)) = v
tkVal_qq_Clause t = error ("rtk internal error: token qq_Clause expected, got " ++ showRtkToken (L.ptToken t))
tkVal_qq_IdList :: L.PosToken -> String
tkVal_qq_IdList (L.PosToken _ (L.Tk__qq_IdList v)) = v
tkVal_qq_IdList t = error ("rtk internal error: token qq_IdList expected, got " ++ showRtkToken (L.ptToken t))
tkVal_qq_Option :: L.PosToken -> String
tkVal_qq_Option (L.PosToken _ (L.Tk__qq_Option v)) = v
tkVal_qq_Option t = error ("rtk internal error: token qq_Option expected, got " ++ showRtkToken (L.ptToken t))
tkVal_qq_OptionList :: L.PosToken -> String
tkVal_qq_OptionList (L.PosToken _ (L.Tk__qq_OptionList v)) = v
tkVal_qq_OptionList t = error ("rtk internal error: token qq_OptionList expected, got " ++ showRtkToken (L.ptToken t))
tkVal_qq_Rule :: L.PosToken -> String
tkVal_qq_Rule (L.PosToken _ (L.Tk__qq_Rule v)) = v
tkVal_qq_Rule t = error ("rtk internal error: token qq_Rule expected, got " ++ showRtkToken (L.ptToken t))
tkVal_qq_RuleList :: L.PosToken -> String
tkVal_qq_RuleList (L.PosToken _ (L.Tk__qq_RuleList v)) = v
tkVal_qq_RuleList t = error ("rtk internal error: token qq_RuleList expected, got " ++ showRtkToken (L.ptToken t))
tkVal_qq_Grammar :: L.PosToken -> String
tkVal_qq_Grammar (L.PosToken _ (L.Tk__qq_Grammar v)) = v
tkVal_qq_Grammar t = error ("rtk internal error: token qq_Grammar expected, got " ++ showRtkToken (L.ptToken t))

data Grammar = Ctr__Grammar__0 RtkPos Grammar |
               Ctr__Grammar__1 RtkPos Clause |
               Ctr__Grammar__2 RtkPos IdList |
               Ctr__Grammar__3 RtkPos Name |
               Ctr__Grammar__4 RtkPos Option |
               Ctr__Grammar__5 RtkPos OptionList |
               Ctr__Grammar__6 RtkPos Rule |
               Ctr__Grammar__7 RtkPos RuleList |
               Ctr__Grammar__8 RtkPos StrLit |
               Anti_Grammar String |
               GrammarDef RtkPos StrLit RuleList |
               GrammarImports RtkPos StrLit String RuleList
               deriving (Ord, Eq, Show, Gen.Data, Gen.Typeable)
instance RtkPosOf Grammar where
    rtkPosOf (Ctr__Grammar__0 p _) = p
    rtkPosOf (Ctr__Grammar__1 p _) = p
    rtkPosOf (Ctr__Grammar__2 p _) = p
    rtkPosOf (Ctr__Grammar__3 p _) = p
    rtkPosOf (Ctr__Grammar__4 p _) = p
    rtkPosOf (Ctr__Grammar__5 p _) = p
    rtkPosOf (Ctr__Grammar__6 p _) = p
    rtkPosOf (Ctr__Grammar__7 p _) = p
    rtkPosOf (Ctr__Grammar__8 p _) = p
    rtkPosOf (Anti_Grammar _) = rtkNoPos
    rtkPosOf (GrammarDef p _ _) = p
    rtkPosOf (GrammarImports p _ _ _) = p
data Clause = Anti_Clause String |
              Ref RtkPos Name |
              Lit RtkPos StrLit |
              Dot RtkPos |
              Regex RtkPos String |
              Star RtkPos Clause |
              StarDelim RtkPos Clause Clause |
              Plus RtkPos Clause |
              PlusDelim RtkPos Clause Clause |
              Opt RtkPos Clause |
              Lifted RtkPos Clause |
              Ignored RtkPos Clause |
              Seq RtkPos Clause Clause |
              Labeled RtkPos Name Clause |
              Alt RtkPos Clause Clause
              deriving (Ord, Eq, Show, Gen.Data, Gen.Typeable)
instance RtkPosOf Clause where
    rtkPosOf (Anti_Clause _) = rtkNoPos
    rtkPosOf (Ref p _) = p
    rtkPosOf (Lit p _) = p
    rtkPosOf (Dot p) = p
    rtkPosOf (Regex p _) = p
    rtkPosOf (Star p _) = p
    rtkPosOf (StarDelim p _ _) = p
    rtkPosOf (Plus p _) = p
    rtkPosOf (PlusDelim p _ _) = p
    rtkPosOf (Opt p _) = p
    rtkPosOf (Lifted p _) = p
    rtkPosOf (Ignored p _) = p
    rtkPosOf (Seq p _ _) = p
    rtkPosOf (Labeled p _ _) = p
    rtkPosOf (Alt p _ _) = p
type IdList = [Name]
data Name = Anti_Name String |
            Ident RtkPos String
            deriving (Ord, Eq, Show, Gen.Data, Gen.Typeable)
instance RtkPosOf Name where
    rtkPosOf (Anti_Name _) = rtkNoPos
    rtkPosOf (Ident p _) = p
data Option = Anti_Option String |
              Shortcuts RtkPos IdList |
              Symmacro RtkPos
              deriving (Ord, Eq, Show, Gen.Data, Gen.Typeable)
instance RtkPosOf Option where
    rtkPosOf (Anti_Option _) = rtkNoPos
    rtkPosOf (Shortcuts p _) = p
    rtkPosOf (Symmacro p) = p
type OptionList = [Option]
data Rule = Anti_Rule String |
            RuleSimple RtkPos Name Clause |
            RuleTyped RtkPos Name Name Clause |
            RuleTypedFunc RtkPos Name Name Name Clause |
            RuleFunc RtkPos Name Name Clause |
            RuleWithOptions RtkPos OptionList Rule
            deriving (Ord, Eq, Show, Gen.Data, Gen.Typeable)
instance RtkPosOf Rule where
    rtkPosOf (Anti_Rule _) = rtkNoPos
    rtkPosOf (RuleSimple p _ _) = p
    rtkPosOf (RuleTyped p _ _ _) = p
    rtkPosOf (RuleTypedFunc p _ _ _ _) = p
    rtkPosOf (RuleFunc p _ _ _) = p
    rtkPosOf (RuleWithOptions p _ _) = p
type RuleList = [Rule]
data StrLit = Anti_StrLit String |
              Str RtkPos String
              deriving (Ord, Eq, Show, Gen.Data, Gen.Typeable)
instance RtkPosOf StrLit where
    rtkPosOf (Anti_StrLit _) = rtkNoPos
    rtkPosOf (Str p _) = p
}