module Parser
where
import Data.Maybe
import UU.Parsing
import UU.Parsing.Machine(RealParser(..),RealRecogn(..),anaDynE,mkPR)
import ConcreteSyntax
import CommonTypes
import Patterns
import UU.Pretty(text,PP_Doc,empty,(>-<))
import TokenDef
import Data.List (intersperse)
import Data.Char
import Scanner (Input(..),scanLit,input)
import System.FilePath
import Data.List
import Expression
import Macro --marcos
import UU.Scanner.Token
import UU.Scanner.TokenParser
import UU.Scanner.GenToken
import UU.Scanner.GenTokenOrd
import UU.Scanner.GenTokenParser
import UU.Scanner.Position
import UU.Scanner.TokenShow()
import System.Directory
import System.FilePath
import HsTokenScanner
import Options
import Scanner(lowercaseKeywords)


type AGParser = AnaParser Input  Pair Token Pos

pIdentifier, pIdentifierU, pIdentifierExcl :: AGParser Identifier
pIdentifierU :: AGParser Identifier
pIdentifierU = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry FilePath -> Pos -> Identifier
Ident forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *). IsParser p Token => p (FilePath, Pos)
pConidPos

-- Jeroen (3-10-2012): for some reason using pKeywordAsIdent
-- drastically slows down parsing of some of my AG files, as
-- in: I thought there was some infinite loop in there, but I
-- guess that eventually it could have given an answer. So
-- probably this does generate a lot of ambiguity.
pIdentifier :: AGParser Identifier
pIdentifier = AGParser Identifier
pIdentifierExcl -- <|> pKeywordAsIdent
pIdentifierExcl :: AGParser Identifier
pIdentifierExcl = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry FilePath -> Pos -> Identifier
Ident forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *). IsParser p Token => p (FilePath, Pos)
pVaridPos

-- see Scanner.lowercaseKeywords for the list of keywords that may
-- be used as an identifier. To prevent ambiguities, it's probably
-- sufficient when the keyword is always followed by a token that
-- can never follow an identifier for any possible prefix.
pKeywordAsIdent :: AGParser Identifier
pKeywordAsIdent :: AGParser Identifier
pKeywordAsIdent = forall (p :: * -> *) s a a1.
IsParser p s =>
(a -> p a1) -> [a] -> p a1
pAny (\FilePath
nm -> FilePath -> Pos -> Identifier
Ident FilePath
nm forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *). IsParser p Token => FilePath -> p Pos
pKeyPos FilePath
nm) [FilePath]
lowercaseKeywords

parseAG :: Options -> [FilePath] -> String -> IO (AG,[Message Token Pos])
parseAG :: Options -> [FilePath] -> FilePath -> IO (AG, [Message Token Pos])
parseAG Options
opts [FilePath]
searchPath FilePath
file = do
  ([Elem]
es,[FilePath]
_,[FilePath]
_,Maybe FilePath
_,[Message Token Pos]
mesg) <- Bool
-> Options
-> [FilePath]
-> FilePath
-> IO
     ([Elem], [FilePath], [FilePath], Maybe FilePath,
      [Message Token Pos])
parseFile Bool
False Options
opts [FilePath]
searchPath FilePath
file
  forall (m :: * -> *) a. Monad m => a -> m a
return ([Elem] -> AG
AG [Elem]
es, [Message Token Pos]
mesg)

--marcos
parseAGI :: Options -> [FilePath] -> String -> IO (AG, Maybe String)
parseAGI :: Options -> [FilePath] -> FilePath -> IO (AG, Maybe FilePath)
parseAGI Options
opts [FilePath]
searchPath FilePath
file
              = do ([Elem]
es,[FilePath]
_,[FilePath]
_,Maybe FilePath
ext,[Message Token Pos]
_) <- Bool
-> Options
-> [FilePath]
-> FilePath
-> IO
     ([Elem], [FilePath], [FilePath], Maybe FilePath,
      [Message Token Pos])
parseFile Bool
True Options
opts [FilePath]
searchPath FilePath
file
                   forall (m :: * -> *) a. Monad m => a -> m a
return ([Elem] -> AG
AG [Elem]
es, Maybe FilePath
ext)


depsAG :: Options -> [FilePath] -> String -> IO ([String], [Message Token Pos])
depsAG :: Options
-> [FilePath] -> FilePath -> IO ([FilePath], [Message Token Pos])
depsAG Options
opts [FilePath]
searchPath FilePath
file
  = do let fn :: FilePath
fn = FilePath -> FilePath
normalise FilePath
file
       ([Elem]
_,[FilePath]
_,[FilePath]
fs,Maybe FilePath
_,[Message Token Pos]
mesgs) <- Bool
-> Options
-> [FilePath]
-> FilePath
-> IO
     ([Elem], [FilePath], [FilePath], Maybe FilePath,
      [Message Token Pos])
parseFile Bool
False Options
opts [FilePath]
searchPath FilePath
fn
       forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. (a -> Bool) -> [a] -> [a]
filter (forall a. Eq a => a -> a -> Bool
/= FilePath
fn) [FilePath]
fs, [Message Token Pos]
mesgs)

-- marcos: added the parameter 'agi' and the 'ext' part
parseFile :: Bool -> Options -> [FilePath] -> String -> IO  ([Elem],[String],[String], Maybe String,[Message Token Pos ])
parseFile :: Bool
-> Options
-> [FilePath]
-> FilePath
-> IO
     ([Elem], [FilePath], [FilePath], Maybe FilePath,
      [Message Token Pos])
parseFile = [FilePath]
-> Bool
-> Options
-> [FilePath]
-> FilePath
-> IO
     ([Elem], [FilePath], [FilePath], Maybe FilePath,
      [Message Token Pos])
parseFile' []

parseFile' :: [String] -> Bool -> Options -> [FilePath] -> String -> IO  ([Elem],[String],[String], Maybe String,[Message Token Pos ])
parseFile' :: [FilePath]
-> Bool
-> Options
-> [FilePath]
-> FilePath
-> IO
     ([Elem], [FilePath], [FilePath], Maybe FilePath,
      [Message Token Pos])
parseFile' [FilePath]
parsedfiles Bool
agi Options
opts [FilePath]
searchPath FilePath
filename
 = do FilePath
file <- FilePath -> FilePath
normalise forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Options -> [FilePath] -> FilePath -> IO FilePath
resolveFile Options
opts [FilePath]
searchPath FilePath
filename
      if FilePath
file forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [FilePath]
parsedfiles 
        then forall (m :: * -> *) a. Monad m => a -> m a
return ([], [], [FilePath]
parsedfiles, forall a. Maybe a
Nothing, [])
        else do
        FilePath
txt <- FilePath -> IO FilePath
readFile FilePath
file
        let searchPath' :: [FilePath]
searchPath' = FilePath -> FilePath
takeDirectory FilePath
file forall a. a -> [a] -> [a]
: [FilePath]
searchPath  -- search first relative to the including file
            litMode :: Bool
litMode = FilePath
".lag" forall a. Eq a => [a] -> [a] -> Bool
`isSuffixOf` FilePath
file
            ([FilePath]
files,FilePath
text) = if Bool
litMode then FilePath -> ([FilePath], FilePath)
scanLit FilePath
txt
                           else ([],FilePath
txt)
            tokens :: Input
tokens       = Options -> Pos -> FilePath -> Input
input Options
opts (FilePath -> Pos
initPos FilePath
file) FilePath
text

            steps :: Steps
  (Pair ([Elem], [FilePath], Maybe FilePath) (Pair Input ()))
  Token
  Pos
steps = forall s inp pos a.
(Symbol s, InputState inp s pos) =>
AnaParser inp Pair s pos a
-> inp -> Steps (Pair a (Pair inp ())) s pos
parse (Bool -> AGParser ([Elem], [FilePath], Maybe FilePath)
pElemsFiles Bool
agi) Input
tokens
            stop :: (a, t a, c, d, e) -> Bool
stop (a
_,t a
fs,c
_,d
_,e
_) = forall (t :: * -> *) a. Foldable t => t a -> Bool
null t a
fs
            cont :: ([Elem], [FilePath], [FilePath], d, [Message Token Pos])
-> IO ([Elem], [FilePath], [FilePath], d, [Message Token Pos])
cont ([Elem]
es,FilePath
f:[FilePath]
fs,[FilePath]
allfs,d
ext,[Message Token Pos]
msg)
              = do ([Elem]
ess,[FilePath]
fss,[FilePath]
allfss,Maybe FilePath
_, [Message Token Pos]
msgs) <- [FilePath]
-> Bool
-> Options
-> [FilePath]
-> FilePath
-> IO
     ([Elem], [FilePath], [FilePath], Maybe FilePath,
      [Message Token Pos])
parseFile' [FilePath]
allfs Bool
agi Options
opts [FilePath]
searchPath' FilePath
f
                   forall (m :: * -> *) a. Monad m => a -> m a
return ([Elem]
ess forall a. [a] -> [a] -> [a]
++ [Elem]
es, [FilePath]
fss forall a. [a] -> [a] -> [a]
++ [FilePath]
fs, [FilePath]
allfss, d
ext, [Message Token Pos]
msg forall a. [a] -> [a] -> [a]
++ [Message Token Pos]
msgs)
        let (Pair ([Elem]
es,[FilePath]
fls,Maybe FilePath
ext) Pair Input ()
_ ,[Message Token Pos]
mesg) = forall s p a.
(Eq s, Show s, Show p) =>
Steps a s p -> (a, [Message s p])
evalStepsMessages Steps
  (Pair ([Elem], [FilePath], Maybe FilePath) (Pair Input ()))
  Token
  Pos
steps
        forall a. (a -> Bool) -> (a -> IO a) -> a -> IO a
loopp forall {t :: * -> *} {a} {a} {c} {d} {e}.
Foldable t =>
(a, t a, c, d, e) -> Bool
stop forall {d}.
([Elem], [FilePath], [FilePath], d, [Message Token Pos])
-> IO ([Elem], [FilePath], [FilePath], d, [Message Token Pos])
cont ([Elem]
es,[FilePath]
files forall a. [a] -> [a] -> [a]
++ [FilePath]
fls,FilePath
file forall a. a -> [a] -> [a]
: [FilePath]
parsedfiles, Maybe FilePath
ext,[Message Token Pos]
mesg)
 where

    --
    -- Option dependent AG Parsers inlined here
    -- to have access to the opts
    -- while retaining sharing
    --

    pElemsFiles :: Bool -> AGParser ([Elem],[String],Maybe String)
    pElemsFiles :: Bool -> AGParser ([Elem], [FilePath], Maybe FilePath)
pElemsFiles Bool
agi = forall (p :: * -> *) s a b.
IsParser p s =>
(a -> b -> b, b) -> p a -> p b
pFoldr (forall a b. (a -> b) -> a -> b
($),([],[],forall a. Maybe a
Nothing)) AnaParser
  Input
  Pair
  Token
  Pos
  (([Elem], [FilePath], Maybe FilePath)
   -> ([Elem], [FilePath], Maybe FilePath))
pElem'
       where pElem' :: AnaParser
  Input
  Pair
  Token
  Pos
  (([Elem], [FilePath], Maybe FilePath)
   -> ([Elem], [FilePath], Maybe FilePath))
pElem' =  forall {a} {b} {c}. a -> ([a], b, c) -> ([a], b, c)
addElem forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Elem
pElem
                   forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AGParser Pos
pINCLUDE forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (forall {b} {a} {c}.
(FilePath, b) -> (a, [FilePath], c) -> (a, [FilePath], c)
addInc forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *). IsParser p Token => p (FilePath, Pos)
pStringPos)
                   forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AGParser Pos
pEXTENDS forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (forall {b} {a}.
(FilePath, b)
-> (a, [FilePath], Maybe FilePath)
-> (a, [FilePath], Maybe FilePath)
addExt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *). IsParser p Token => p (FilePath, Pos)
pStringPos)
             addElem :: a -> ([a], b, c) -> ([a], b, c)
addElem a
e      ([a]
es,b
fs,c
ext) = (a
eforall a. a -> [a] -> [a]
:[a]
es,   b
fs, c
ext)
             addInc :: (FilePath, b) -> (a, [FilePath], c) -> (a, [FilePath], c)
addInc  (FilePath
fn,b
_) (a
es,[FilePath]
fs,c
ext) 
               | Options -> Bool
noIncludes Options
opts = (a
es, [FilePath]
fs, c
ext)  -- skip includes
               | Bool
otherwise       = (a
es,FilePath -> FilePath
normalise FilePath
fnforall a. a -> [a] -> [a]
:[FilePath]
fs, c
ext)
             addExt :: (FilePath, b)
-> (a, [FilePath], Maybe FilePath)
-> (a, [FilePath], Maybe FilePath)
addExt  (FilePath
fn,b
_) (a
es,[FilePath]
fs,Maybe FilePath
ext)
               | Options -> Bool
noIncludes Options
opts = (a
es, [FilePath]
fs, Maybe FilePath
ext)  -- skip includes
               | Bool
otherwise       = if Bool
agi then (a
es,[FilePath]
fs, forall a. a -> Maybe a
Just FilePath
fn') else (a
es,FilePath
fn'forall a. a -> [a] -> [a]
:[FilePath]
fs, Maybe FilePath
ext) --marcos
               where fn' :: FilePath
fn' = FilePath -> FilePath
normalise FilePath
fn

    pCodescrapL :: AnaParser Input Pair Token Pos (FilePath, Pos)
pCodescrapL = (\(ValToken EnumValToken
_ FilePath
str Pos
pos) -> (FilePath
str, Pos
pos))forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                        AGParser Token
parseScrapL forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"a code block"

    parseScrapL :: AGParser Token
    parseScrapL :: AGParser Token
parseScrapL
               = let p :: (Token -> a -> b) -> (Input -> Steps a s p) -> Input -> Steps b s p
p Token -> a -> b
acc =  (\Input -> Steps a s p
k (Input Pos
pos FilePath
str Maybe (Token, Input)
next) ->
                               let (Token
sc,Input
rest) = case Maybe (Token, Input)
next of
                                     Just (t :: Token
t@(ValToken EnumValToken
TkTextln FilePath
_ Pos
_), Input
rs) -> (Token
t,Input
rs)
                                     Maybe (Token, Input)
_ -> let (Token
tok,Pos
p2,FilePath
inp2) = Pos -> FilePath -> (Token, Pos, FilePath)
codescrapL Pos
pos FilePath
str
                                          in (Token
tok, Options -> Pos -> FilePath -> Input
input Options
opts Pos
p2 FilePath
inp2)
                                   steps :: Steps a s p
steps   = Input -> Steps a s p
k ( Input
rest)
                               in  (forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val (Token -> a -> b
acc Token
sc)  Steps a s p
steps)
                          )
                 in forall {state} {result :: * -> * -> *} {s} {p} {a}.
ParsRec state result s p a -> AnaParser state result s p a
anaDynE  (forall {result :: * -> * -> *} {state} {s} {p} {a}.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR (forall state s p a.
(forall r' r''.
 (a -> r'' -> r')
 -> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P (forall {a} {b} {s} {p}.
(Token -> a -> b) -> (Input -> Steps a s p) -> Input -> Steps b s p
p  ), forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R (forall {a} {b} {s} {p}.
(Token -> a -> b) -> (Input -> Steps a s p) -> Input -> Steps b s p
p (forall a b. a -> b -> a
const forall a. a -> a
id))))

    pElems :: AGParser Elems
    pElems :: AGParser [Elem]
pElems = forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList_ng AGParser Elem
pElem

    pComplexType :: AnaParser Input Pair Token Pos ComplexType
pComplexType =  Type -> ComplexType
List   forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) a. IsParser p Token => p a -> p a
pBracks AGParser Type
pTypeEncapsulated
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Type -> ComplexType
Maybe  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pMAYBE forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pType
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Type -> Type -> ComplexType
Either forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pEITHER forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pType forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pType
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Type -> Type -> ComplexType
Map    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pMAP forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pTypePrimitive forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pType
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Type -> ComplexType
IntMap forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pINTMAP forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pType
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Type -> ComplexType
OrdSet forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pSET forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pType
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ComplexType
IntSet forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pINTSET
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [(Maybe Identifier, Type)] -> ComplexType
tuple  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) a. IsParser p Token => p a -> p a
pParens (forall (p :: * -> *) s a a1. IsParser p s => p a -> p a1 -> p [a1]
pListSep forall (p :: * -> *). IsParser p Token => p FilePath
pComma AnaParser Input Pair Token Pos (Maybe Identifier, Type)
field)
      where field :: AnaParser Input Pair Token Pos (Maybe Identifier, Type)
field = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pTypeColon) forall (p :: * -> *) s a. IsParser p s => p a -> a -> p a
`opt` forall a. Maybe a
Nothing) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pTypeEncapsulated
            tuple :: [(Maybe Identifier, Type)] -> ComplexType
tuple [(Maybe Identifier, Type)]
xs = [(Identifier, Type)] -> ComplexType
Tuple [(forall a. a -> Maybe a -> a
fromMaybe (FilePath -> Pos -> Identifier
Ident (FilePath
"x"forall a. [a] -> [a] -> [a]
++forall a. Show a => a -> FilePath
show Integer
n) Pos
noPos) Maybe Identifier
f, Type
t)
                             | (Integer
n,(Maybe Identifier
f,Type
t)) <- forall a b. [a] -> [b] -> [(a, b)]
zip [Integer
1..] [(Maybe Identifier, Type)]
xs
                             ]

    pOptClassContext' :: AGParser ClassContext
    pOptClassContext' :: AGParser ClassContext
pOptClassContext'
      | Options -> Bool
ocaml Options
opts = forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed []
      | Bool
otherwise  = AGParser ClassContext
pOptClassContext

    pTyVars :: AGParser [Identifier]
    pTyVars :: AGParser [Identifier]
pTyVars
      | Options -> Bool
ocaml Options
opts = forall (m :: * -> *) a. Monad m => a -> m a
return forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pTypeVar
                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed []
                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (p :: * -> *) a. IsParser p Token => p a -> p a
pParens (forall (p :: * -> *) s a a1. IsParser p s => p a -> p a1 -> p [a1]
pListSep forall (p :: * -> *). IsParser p Token => p FilePath
pComma AGParser Identifier
pTypeVar)
      | Bool
otherwise  = forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList AGParser Identifier
pIdentifier

    pElem :: AGParser Elem
    pElem :: AGParser Elem
pElem
         =  (\(Pos
pos, ConstructorType
ct) -> Pos
-> ConstructorType
-> ClassContext
-> NontSet
-> [Identifier]
-> Attrs
-> Alts
-> Bool
-> Elem
Data Pos
pos ConstructorType
ct)
                 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (    (\Pos
x -> (Pos
x, ConstructorType
DataConstructor))   forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (AGParser Pos
pDATA forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AGParser Pos
pTYPE)
                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>  (\Pos
x -> (Pos
x, ConstructorType
RecordConstructor)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pRECORD
                     )
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser ClassContext
pOptClassContext'
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnaParser Input Pair Token Pos NontSet
pNontSet
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser [Identifier]
pTyVars
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Attrs
pOptAttrs
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Alts
pAlts
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed Bool
False
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Pos -> ClassContext -> NontSet -> [FilePath] -> Attrs -> Elem
Attr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pATTR
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser ClassContext
pOptClassContext'
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnaParser Input Pair Token Pos NontSet
pNontSet
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser [FilePath]
pOptQuantifiers
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Attrs
pAttrs
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Pos
-> ClassContext
-> Identifier
-> [Identifier]
-> ComplexType
-> Elem
Type forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pTYPE
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser ClassContext
pOptClassContext'
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pTypeCon
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser [Identifier]
pTyVars
                 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  AGParser Pos
pEquals
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnaParser Input Pair Token Pos ComplexType
pComplexType
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Pos
-> ClassContext
-> NontSet
-> Attrs
-> [FilePath]
-> SemAlts
-> Elem
Sem  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pSEM
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser ClassContext
pOptClassContext'
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnaParser Input Pair Token Pos NontSet
pNontSet
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Attrs
pOptAttrs
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser [FilePath]
pOptQuantifiers
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser SemAlts
pSemAlts
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Pos -> Identifier -> Bool -> NontSet -> Elem
Set  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pSET
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pTypeCon
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (   Bool
False forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pEquals
                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool
True  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pColon
                     )
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnaParser Input Pair Token Pos NontSet
pNontSet
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Pos -> NontSet -> [Identifier] -> Elem
Deriving
                 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pDERIVING
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnaParser Input Pair Token Pos NontSet
pNontSet
                 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  AGParser Pos
pColon
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a a1. IsParser p s => p a -> p a1 -> p [a1]
pListSep forall (p :: * -> *). IsParser p Token => p FilePath
pComma AGParser Identifier
pIdentifierU
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Pos -> NontSet -> Elem
Wrapper
                 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pWRAPPER
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnaParser Input Pair Token Pos NontSet
pNontSet
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Pos -> NontSet -> Elem
Nocatas
                 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pNOCATAS
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnaParser Input Pair Token Pos NontSet
pNontSet
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Pos -> [Identifier] -> Elem
Pragma
                 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pPRAGMA
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList1 AGParser Identifier
pIdentifier
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Pos -> FilePath -> FilePath -> FilePath -> Elem
Module
                 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pMODULE
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser FilePath
pCodescrap'
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser FilePath
pCodescrap'
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser FilePath
pCodescrap'
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> BlockKind -> Maybe Identifier -> (FilePath, Pos) -> Elem
codeBlock forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser BlockKind
pBlockKind forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pATTACH forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pTypeCon) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed forall a. Maybe a
Nothing) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnaParser Input Pair Token Pos (FilePath, Pos)
pCodeBlock forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"a statement"
              where codeBlock :: BlockKind -> Maybe Identifier -> (FilePath, Pos) -> Elem
codeBlock BlockKind
knd Maybe Identifier
mbNt (FilePath
txt,Pos
pos) = Pos -> BlockKind -> Maybe Identifier -> [FilePath] -> Elem
Txt Pos
pos BlockKind
knd Maybe Identifier
mbNt (FilePath -> [FilePath]
lines FilePath
txt)                 

    pBlockKind :: AGParser BlockKind
    pBlockKind :: AGParser BlockKind
pBlockKind =
          BlockKind
BlockPragma forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pOPTPRAGMAS
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> BlockKind
BlockImport forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pIMPORTS
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> BlockKind
BlockMain   forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pTOPLEVEL   -- block is moved to the toplevel ("main") module when "sepsemmods" is used
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> BlockKind
BlockData   forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pDATABLOCK
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> BlockKind
BlockRec    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pRECBLOCK
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed BlockKind
BlockOther

    pAttrs :: AGParser Attrs
    pAttrs :: AGParser Attrs
pAttrs
        = Pos -> AttrNames -> AttrNames -> AttrNames -> Attrs
Attrs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *). IsParser p Token => p Pos
pOBrackPos forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList AnaParser Input Pair Token Pos AttrNames
pInhAttrNames forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"inherited attribute declarations")
                                  forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pBar    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList AnaParser Input Pair Token Pos AttrNames
pAttrNames forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"chained attribute declarations"  )
                                  forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pBar    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList AnaParser Input Pair Token Pos AttrNames
pAttrNames forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"synthesised attribute declarations"  )
                   forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  forall (p :: * -> *). IsParser p Token => p FilePath
pCBrack
           forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\[(Pos, (AttrNames, AttrNames, AttrNames))]
ds -> Pos -> AttrNames -> AttrNames -> AttrNames -> Attrs
Attrs (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. [a] -> a
head [(Pos, (AttrNames, AttrNames, AttrNames))]
ds) [(Identifier, Type, (FilePath, FilePath, FilePath))
n | (Pos
_,(AttrNames
nms,AttrNames
_,AttrNames
_)) <- [(Pos, (AttrNames, AttrNames, AttrNames))]
ds, (Identifier, Type, (FilePath, FilePath, FilePath))
n <- AttrNames
nms] [(Identifier, Type, (FilePath, FilePath, FilePath))
n | (Pos
_,(AttrNames
_,AttrNames
nms,AttrNames
_)) <- [(Pos, (AttrNames, AttrNames, AttrNames))]
ds, (Identifier, Type, (FilePath, FilePath, FilePath))
n <- AttrNames
nms] [(Identifier, Type, (FilePath, FilePath, FilePath))
n | (Pos
_,(AttrNames
_,AttrNames
_,AttrNames
nms)) <- [(Pos, (AttrNames, AttrNames, AttrNames))]
ds, (Identifier, Type, (FilePath, FilePath, FilePath))
n <- AttrNames
nms]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList1 AGParser (Pos, (AttrNames, AttrNames, AttrNames))
pSingleAttrDefs

    pSingleAttrDefs :: AGParser (Pos, (AttrNames, AttrNames, AttrNames))
    pSingleAttrDefs :: AGParser (Pos, (AttrNames, AttrNames, AttrNames))
pSingleAttrDefs
      =    (\Pos
p AttrNames
is -> (Pos
p, (AttrNames
is,[],[]))) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pINH forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a a1. IsParser p s => p a -> p a1 -> p [a1]
pList1Sep forall (p :: * -> *). IsParser p Token => p FilePath
pComma AGParser (Identifier, Type, (FilePath, FilePath, FilePath))
pSingleInhAttrDef
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>  (\Pos
p AttrNames
is -> (Pos
p, ([],[],AttrNames
is))) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pSYN forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a a1. IsParser p s => p a -> p a1 -> p [a1]
pList1Sep forall (p :: * -> *). IsParser p Token => p FilePath
pComma AGParser (Identifier, Type, (FilePath, FilePath, FilePath))
pSingleSynAttrDef
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>  (\Pos
p AttrNames
is -> (Pos
p, ([],AttrNames
is,[]))) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pCHN forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a a1. IsParser p s => p a -> p a1 -> p [a1]
pList1Sep forall (p :: * -> *). IsParser p Token => p FilePath
pComma AGParser (Identifier, Type, (FilePath, FilePath, FilePath))
pSingleChnAttrDef

    pSingleInhAttrDef :: AGParser (Identifier,Type,(String,String,String))
    pSingleInhAttrDef :: AGParser (Identifier, Type, (FilePath, FilePath, FilePath))
pSingleInhAttrDef
      = (\Identifier
v Type
tp -> (Identifier
v,Type
tp,(FilePath
"",FilePath
"",FilePath
""))) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pAttrIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pTypeColon forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pTypeOrSelf forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"inh attribute declaration"

    pSingleSynAttrDef :: AGParser (Identifier,Type,(String,String,String))
    pSingleSynAttrDef :: AGParser (Identifier, Type, (FilePath, FilePath, FilePath))
pSingleSynAttrDef
      = (\Identifier
v (FilePath, FilePath, FilePath)
u Type
tp -> (Identifier
v,Type
tp,(FilePath, FilePath, FilePath)
u)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pAttrIdentifier forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser (FilePath, FilePath, FilePath)
pUse forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pTypeColon forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pTypeOrSelf forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"syn attribute declaration"

    pSingleChnAttrDef :: AGParser (Identifier,Type,(String,String,String))
    pSingleChnAttrDef :: AGParser (Identifier, Type, (FilePath, FilePath, FilePath))
pSingleChnAttrDef
      = (\Identifier
v Type
tp -> (Identifier
v,Type
tp,(FilePath
"",FilePath
"",FilePath
""))) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pAttrIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pTypeColon forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pTypeOrSelf forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"chn attribute declaration"

    pOptAttrs :: AGParser Attrs
    pOptAttrs :: AGParser Attrs
pOptAttrs = AGParser Attrs
pAttrs forall (p :: * -> *) s a. IsParser p s => p a -> a -> p a
`opt` Pos -> AttrNames -> AttrNames -> AttrNames -> Attrs
Attrs Pos
noPos [] [] []

    pInhAttrNames :: AGParser AttrNames
    pInhAttrNames :: AnaParser Input Pair Token Pos AttrNames
pInhAttrNames
                   = (\[Identifier]
vs Type
tp -> forall a b. (a -> b) -> [a] -> [b]
map (\Identifier
v -> (Identifier
v,Type
tp,(FilePath
"",FilePath
"",FilePath
""))) [Identifier]
vs)
                      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser [Identifier]
pAttrIdentifiers forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  AGParser Pos
pTypeColon forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pTypeOrSelf forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"attribute declarations"

    pAttrNames :: AGParser AttrNames
    pAttrNames :: AnaParser Input Pair Token Pos AttrNames
pAttrNames
             = (\[Identifier]
vs (FilePath, FilePath, FilePath)
use Type
tp -> forall a b. (a -> b) -> [a] -> [b]
map (\Identifier
v -> (Identifier
v,Type
tp,(FilePath, FilePath, FilePath)
use)) [Identifier]
vs)
                 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser [Identifier]
pAttrIdentifiers forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser (FilePath, FilePath, FilePath)
pUse forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pTypeColon forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pTypeOrSelf forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"attribute declarations"

    pAlt :: AGParser Alt
    pAlt :: AGParser Alt
pAlt =   (Pos
-> ConstructorSet -> [Identifier] -> Fields -> MaybeMacro -> Alt
Alt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pBar forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser ConstructorSet
pSimpleConstructorSet forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList1_ng AGParser Identifier
pTypeVar forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pDot forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed []) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Fields
pFields forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser MaybeMacro
pMaybeMacro forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"a datatype alternative")

    pAlts :: AGParser Alts
    pAlts :: AGParser Alts
pAlts =  forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList_ng AGParser Alt
pAlt forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"datatype alternatives"

    pFields :: AGParser Fields
    pFields :: AGParser Fields
pFields = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList_ng AGParser Fields
pField forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"fields"

    pField :: AGParser Fields
    pField :: AGParser Fields
pField
           =   (\[Identifier]
nms Type
tp -> forall a b. (a -> b) -> [a] -> [b]
map (\Identifier
nm -> Identifier -> Type -> Field
FChild Identifier
nm Type
tp) [Identifier]
nms) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser [Identifier]
pAttrIdentifiers forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pTypeColon forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pType
           forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Identifier
s   -> [Identifier -> Type -> Field
FChild (FilePath -> Pos -> Identifier
Ident (FilePath -> FilePath
mklower forall a b. (a -> b) -> a -> b
$ Identifier -> FilePath
getName Identifier
s) (Identifier -> Pos
getPos Identifier
s)) (Identifier -> [FilePath] -> Bool -> Type
NT Identifier
s [] Bool
False)]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pIdentifierU
           forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Type
t   -> [[Type] -> Field
FCtx [Type
t]]) forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pSmallerEqual forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pTypePrimitive
    
    pSemAlt :: AGParser SemAlt
    pSemAlt :: AGParser SemAlt
pSemAlt = Pos -> ConstructorSet -> SemDefs -> SemAlt
SemAlt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pBar forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser ConstructorSet
pConstructorSet forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser SemDefs
pSemDefs forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"SEM alternative"

    pSemAlts :: AGParser SemAlts
    pSemAlts :: AGParser SemAlts
pSemAlts =  forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList AGParser SemAlt
pSemAlt forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"SEM alternatives"

    pSemDef :: AGParser [SemDef]
    pSemDef :: AGParser SemDefs
pSemDef
          =   (\Maybe Identifier
x Identifier
y [Maybe Identifier -> Identifier -> SemDef]
fs -> forall a b. (a -> b) -> [a] -> [b]
map (\Maybe Identifier -> Identifier -> SemDef
f -> Maybe Identifier -> Identifier -> SemDef
f Maybe Identifier
x Identifier
y) [Maybe Identifier -> Identifier -> SemDef]
fs) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AnaParser Input Pair Token Pos (Maybe Identifier)
pMaybeRuleName forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pFieldIdentifier forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList1 AGParser (Maybe Identifier -> Identifier -> SemDef)
pAttrDef
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>                            AGParser Pos
pLOC              forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList1 AGParser SemDef
pLocDecl
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>                            AGParser Pos
pINST             forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList1 AGParser SemDef
pInstDecl
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>  AGParser Pos
pSEMPRAGMA forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList1 ([Identifier] -> SemDef
SemPragma forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser [Identifier]
pNames)
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Identifier
n Expression
e -> [Identifier -> Expression -> SemDef
AugmentDef Identifier
n Expression
e]) forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser ()
pAugmentToken forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pAttrIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AnaParser Input Pair Token Pos Bool
pAssign forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Expression
pExpr
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Identifier
n Expression
e -> [Identifier -> Expression -> SemDef
AroundDef Identifier
n Expression
e]) forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pAROUND forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pAttrIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AnaParser Input Pair Token Pos Bool
pAssign forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Expression
pExpr
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\[Occurrence]
a Occurrence
b -> [[Occurrence] -> [Occurrence] -> SemDef
AttrOrderBefore [Occurrence]
a [Occurrence
b]]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList1 AnaParser Input Pair Token Pos Occurrence
pAttrOrIdent forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pSmaller forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnaParser Input Pair Token Pos Occurrence
pAttrOrIdent
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\[Identifier]
sources Identifier
target Identifier
nt Expression
expr -> [Identifier -> Identifier -> [Identifier] -> Expression -> SemDef
MergeDef Identifier
target Identifier
nt [Identifier]
sources Expression
expr]) forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pMERGE forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList1_ng AGParser Identifier
pIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pAS forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed []) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pTypeColon forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pIdentifierU forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AnaParser Input Pair Token Pos Bool
pAssign forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Expression
pExpr
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Maybe Identifier
mbNm () -> Pattern
pat (Bool
owrt,Pos
pos,Bool
pur,Bool
eager) Expression
exp -> [Pos
-> Maybe Identifier
-> Pattern
-> Expression
-> Bool
-> Bool
-> Bool
-> SemDef
Def Pos
pos Maybe Identifier
mbNm (() -> Pattern
pat ()) Expression
exp Bool
owrt Bool
pur Bool
eager]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AnaParser Input Pair Token Pos (Maybe Identifier)
pMaybeRuleName forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a.
AGParser (a -> (Identifier, Identifier)) -> AGParser (a -> Pattern)
pPattern (forall a b. a -> b -> a
const forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AnaParser Input Pair Token Pos (Identifier, Identifier)
pAttr) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser (Bool, Pos, Bool, Bool)
pRuleSym forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Expression
pExpr

    pMaybeRuleName :: AGParser (Maybe Identifier)
    pMaybeRuleName :: AnaParser Input Pair Token Pos (Maybe Identifier)
pMaybeRuleName
      =   (forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pColon forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"rule name")
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed forall a. Maybe a
Nothing

    pAttrDef :: AGParser (Maybe Identifier -> Identifier -> SemDef)
    pAttrDef :: AGParser (Maybe Identifier -> Identifier -> SemDef)
pAttrDef
      = (\Identifier -> Pattern
pat (Bool
owrt,Pos
pos,Bool
pur,Bool
eager) Expression
exp Maybe Identifier
mbNm Identifier
fld -> Pos
-> Maybe Identifier
-> Pattern
-> Expression
-> Bool
-> Bool
-> Bool
-> SemDef
Def Pos
pos Maybe Identifier
mbNm (Identifier -> Pattern
pat Identifier
fld) Expression
exp Bool
owrt Bool
pur Bool
eager)
               forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pDot forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AnaParser Input Pair Token Pos (Identifier -> Pattern)
pattern forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser (Bool, Pos, Bool, Bool)
pRuleSym forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Expression
pExpr
      where pattern :: AnaParser Input Pair Token Pos (Identifier -> Pattern)
pattern =  forall a.
AGParser (a -> (Identifier, Identifier)) -> AGParser (a -> Pattern)
pPattern AGParser (Identifier -> (Identifier, Identifier))
pVar
                   forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Pattern -> Pattern
ir Identifier
a Identifier
fld -> Pattern -> Pattern
ir forall a b. (a -> b) -> a -> b
$ Identifier -> Identifier -> Pattern -> Pattern
Alias Identifier
fld Identifier
a (Pos -> Pattern
Underscore Pos
noPos)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Pattern -> Pattern
Irrefutable forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pTilde) forall (p :: * -> *) s a. IsParser p s => p a -> a -> p a
`opt` forall a. a -> a
id) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pAttrIdentifier

    pLocDecl :: AGParser SemDef
    pLocDecl :: AGParser SemDef
pLocDecl = AGParser Pos
pDot forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> (AGParser Identifier
pIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> (AGParser Pos
pTypeColon forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> (   (\(Type
tp,Pos
pos) Pos
_ Identifier
ident Pos
_  -> Pos -> Identifier -> Type -> SemDef
TypeDef Pos
pos Identifier
ident Type
tp) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser (Type, Pos)
pLocType
                                                            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Identifier
ref Pos
_ Identifier
ident Pos
_ -> Identifier -> Identifier -> SemDef
UniqueDef Identifier
ident Identifier
ref) forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pUNIQUEREF forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pIdentifier )))

    pLocType :: AGParser (Type, Pos)
    pLocType :: AGParser (Type, Pos)
pLocType = (\Identifier
u -> (FilePath -> Type
Haskell forall a b. (a -> b) -> a -> b
$ Identifier -> FilePath
getName Identifier
u, Identifier -> Pos
getPos Identifier
u)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pTypeCon
       forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\(FilePath
s,Pos
p) -> (FilePath -> Type
Haskell FilePath
s,Pos
p)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AnaParser Input Pair Token Pos (FilePath, Pos)
pCodescrap  forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"a type"

    pInstDecl :: AGParser SemDef
    pInstDecl :: AGParser SemDef
pInstDecl = (\Identifier
ident Type
tp -> Pos -> Identifier -> Type -> SemDef
TypeDef (Identifier -> Pos
getPos Identifier
ident) Identifier
ident Type
tp)
                  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pDot forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pTypeColon forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Type
pTypeNt

    pSemDefs :: AGParser SemDefs
    pSemDefs :: AGParser SemDefs
pSemDefs =  forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList_ng AGParser SemDefs
pSemDef forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"attribute rules"

    pExpr :: AGParser Expression
    pExpr :: AGParser Expression
pExpr = (\(FilePath
str,Pos
pos) ->  Pos -> [HsToken] -> Expression
Expression Pos
pos (Options -> Pos -> FilePath -> [HsToken]
lexTokens Options
opts Pos
pos FilePath
str)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AnaParser Input Pair Token Pos (FilePath, Pos)
pCodescrapL forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"an expression"

    pTypeColon :: AGParser Pos
    pTypeColon :: AGParser Pos
pTypeColon
      = if Options -> Bool
doubleColons Options
opts
        then AGParser Pos
pDoubleColon
        else AGParser Pos
pColon

    --marcos
    pMaybeMacro :: AGParser MaybeMacro
    pMaybeMacro :: AGParser MaybeMacro
pMaybeMacro  =  forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pDoubleArrow forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  AGParser Macro
pMacro
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed forall a. Maybe a
Nothing

    pMacro :: AGParser Macro
    pMacro :: AGParser Macro
pMacro
          =  Identifier -> MacroChildren -> Macro
Macro forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pIdentifierU
                   forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList1 AGParser MacroChild
pMacroChild
                   forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"macro"

    pMacroChild :: AGParser MacroChild
    pMacroChild :: AGParser MacroChild
pMacroChild
          =  (AGParser Identifier
pIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pEquals) forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**>
             (forall a b c. (a -> b -> c) -> b -> a -> c
flip Identifier -> Macro -> MacroChild
RuleChild   forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Macro
pMacro       forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
              forall a b c. (a -> b -> c) -> b -> a -> c
flip Identifier -> Identifier -> MacroChild
ChildChild  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pIdentifier  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
              forall a b c. (a -> b -> c) -> b -> a -> c
flip Identifier -> FilePath -> MacroChild
ValueChild  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser FilePath
pCodescrap' )

    pTypeNt :: AGParser Type
    pTypeNt :: AGParser Type
pTypeNt
      =   ((\Identifier
nt -> Identifier -> [FilePath] -> Type
mkNtType Identifier
nt []) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pTypeCon forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"nonterminal name (no brackets)")
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall (p :: * -> *) a. IsParser p Token => p a -> p a
pParens (Identifier -> [FilePath] -> Type
mkNtType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pTypeCon forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList AGParser FilePath
pTypeHaskellAnyAsString) forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"nonterminal name with parameters (using parenthesis)")

    pTypeCon :: AGParser Identifier
    pTypeCon :: AGParser Identifier
pTypeCon
      | Options -> Bool
ocaml Options
opts = AGParser Identifier
pIdentifierExcl
      | Bool
otherwise  = AGParser Identifier
pIdentifierU

    pTypeVar :: AGParser Identifier
    pTypeVar :: AGParser Identifier
pTypeVar
      | Options -> Bool
ocaml Options
opts = (\(FilePath
nm, Pos
pos) -> FilePath -> Pos -> Identifier
Ident FilePath
nm Pos
pos) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *). IsParser p Token => p (FilePath, Pos)
pTextnmPos
      | Bool
otherwise  = AGParser Identifier
pIdentifier

    pTypeHaskellAnyAsString :: AGParser String
    pTypeHaskellAnyAsString :: AGParser FilePath
pTypeHaskellAnyAsString
      =   Identifier -> FilePath
getName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pTypeVar
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Identifier -> FilePath
getName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pTypeCon
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AGParser FilePath
pCodescrap' forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"a type"

    -- if the type is within some kind of parentheses or brackets (then we allow lowercase identifiers as well)
    pTypeEncapsulated :: AGParser Type
    pTypeEncapsulated :: AGParser Type
pTypeEncapsulated
      =   forall (p :: * -> *) a. IsParser p Token => p a -> p a
pParens AGParser Type
pTypeEncapsulated
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Identifier -> [FilePath] -> Type
mkNtType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pTypeCon forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList AGParser FilePath
pTypeHaskellAnyAsString
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (FilePath -> Type
Haskell forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> FilePath
getName) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pTypeVar
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AGParser Type
pTypePrimitive

    pTypePrimitive :: AGParser Type
    pTypePrimitive :: AGParser Type
pTypePrimitive
      = FilePath -> Type
Haskell forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser FilePath
pCodescrap'  forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"a type"

    pType :: AGParser Type
    pType :: AGParser Type
pType =  AGParser Type
pTypeNt
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AGParser Type
pTypePrimitive

    pTypeOrSelf :: AGParser Type
    pTypeOrSelf :: AGParser Type
pTypeOrSelf = AGParser Type
pType forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Type
Self forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pSELF

    pOptClassContext :: AGParser ClassContext
    pOptClassContext :: AGParser ClassContext
pOptClassContext
      =   AGParser ClassContext
pClassContext forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pDoubleArrow
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed []

    pClassContext :: AGParser ClassContext
    pClassContext :: AGParser ClassContext
pClassContext
      = forall (p :: * -> *) s a a1. IsParser p s => p a -> p a1 -> p [a1]
pListSep forall (p :: * -> *). IsParser p Token => p FilePath
pComma ((,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pIdentifierU forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList AGParser FilePath
pTypeHaskellAnyAsString)

    pNontSet :: AnaParser Input Pair Token Pos NontSet
pNontSet = AnaParser Input Pair Token Pos NontSet
set0 where
        set0 :: AnaParser Input Pair Token Pos NontSet
set0 = forall (p :: * -> *) s c.
IsParser p s =>
p (c -> c -> c) -> p c -> p c
pChainr (NontSet -> NontSet -> NontSet
Intersect forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pIntersect) AnaParser Input Pair Token Pos NontSet
set1
        set1 :: AnaParser Input Pair Token Pos NontSet
set1 = forall (p :: * -> *) s c.
IsParser p s =>
p (c -> c -> c) -> p c -> p c
pChainl (NontSet -> NontSet -> NontSet
Difference forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pMinus) AnaParser Input Pair Token Pos NontSet
set2
        set2 :: AnaParser Input Pair Token Pos NontSet
set2 = forall (p :: * -> *) s c.
IsParser p s =>
p (c -> c -> c) -> p c -> p c
pChainr (forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed NontSet -> NontSet -> NontSet
Union) AnaParser Input Pair Token Pos NontSet
set3
        set3 :: AnaParser Input Pair Token Pos NontSet
set3 = AGParser Identifier
pTypeCon forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> forall (p :: * -> *) s a. IsParser p s => p a -> a -> p a
opt (forall a b c. (a -> b -> c) -> b -> a -> c
flip Identifier -> Identifier -> NontSet
Path forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pArrow forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pTypeCon) Identifier -> NontSet
NamedSet
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NontSet
All forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pStar
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (p :: * -> *) a. IsParser p Token => p a -> p a
pParens AnaParser Input Pair Token Pos NontSet
set0

    --
    -- End of AG Parser
    --

resolveFile :: Options -> [FilePath] -> FilePath -> IO FilePath
resolveFile :: Options -> [FilePath] -> FilePath -> IO FilePath
resolveFile Options
opts [FilePath]
path FilePath
fname = [FilePath] -> IO FilePath
search ([FilePath]
path forall a. [a] -> [a] -> [a]
++ [FilePath
"."])
 where search :: [FilePath] -> IO FilePath
search (FilePath
p:[FilePath]
ps) = do let filename :: FilePath
filename = [FilePath] -> FilePath
joinPath [FilePath
p, FilePath
fname]
                          Bool
fExists <- FilePath -> IO Bool
doesFileExist FilePath
filename
                          if Bool
fExists
                            then forall (m :: * -> *) a. Monad m => a -> m a
return FilePath
filename
                            else do let filename' :: FilePath
filename' = [FilePath] -> FilePath
joinPath [FilePath
p, FilePath -> FilePath -> FilePath
replaceExtension FilePath
fname FilePath
"ag"]
                                    Bool
fExists' <- FilePath -> IO Bool
doesFileExist FilePath
filename'
                                    if Bool
fExists'
                                      then forall (m :: * -> *) a. Monad m => a -> m a
return FilePath
filename'
                                      else [FilePath] -> IO FilePath
search [FilePath]
ps
       search []     = do
         Options -> FilePath -> IO ()
outputStr Options
opts (FilePath
"File: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> FilePath
show FilePath
fname forall a. [a] -> [a] -> [a]
++ FilePath
" not found in search path: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> FilePath
show (forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (forall a. a -> [a] -> [a]
intersperse FilePath
";" ([FilePath]
path forall a. [a] -> [a] -> [a]
++ [FilePath
"."]))) forall a. [a] -> [a] -> [a]
++ FilePath
"\n")
         Options -> Int -> IO ()
failWithCode Options
opts Int
1
         forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. HasCallStack => FilePath -> a
error FilePath
"resolveFile: file not found")

evalStepsMessages :: (Eq s, Show s, Show p) => Steps a s p -> (a,[Message s p])
evalStepsMessages :: forall s p a.
(Eq s, Show s, Show p) =>
Steps a s p -> (a, [Message s p])
evalStepsMessages Steps a s p
steps = case Steps a s p
steps of
  OkVal a -> a
v        Steps a s p
rest -> let (a
arg,[Message s p]
ms) = forall s p a.
(Eq s, Show s, Show p) =>
Steps a s p -> (a, [Message s p])
evalStepsMessages Steps a s p
rest
                         in (a -> a
v a
arg,[Message s p]
ms)
  Ok             Steps a s p
rest -> forall s p a.
(Eq s, Show s, Show p) =>
Steps a s p -> (a, [Message s p])
evalStepsMessages Steps a s p
rest
  Cost  Int#
_        Steps a s p
rest -> forall s p a.
(Eq s, Show s, Show p) =>
Steps a s p -> (a, [Message s p])
evalStepsMessages Steps a s p
rest
  StRepair Int#
_ Message s p
msg Steps a s p
rest -> let (a
v,[Message s p]
ms) = forall s p a.
(Eq s, Show s, Show p) =>
Steps a s p -> (a, [Message s p])
evalStepsMessages Steps a s p
rest
                         in (a
v, Message s p
msgforall a. a -> [a] -> [a]
:[Message s p]
ms)
  Best Steps a s p
_   Steps a s p
rest   Steps a s p
_   -> forall s p a.
(Eq s, Show s, Show p) =>
Steps a s p -> (a, [Message s p])
evalStepsMessages Steps a s p
rest
  NoMoreSteps a
v       -> (a
v,[])

loopp ::(a->Bool) -> (a->IO a) -> a ->  IO a
loopp :: forall a. (a -> Bool) -> (a -> IO a) -> a -> IO a
loopp a -> Bool
pred a -> IO a
cont a
x | a -> Bool
pred a
x = forall (m :: * -> *) a. Monad m => a -> m a
return a
x
                  | Bool
otherwise = do a
x' <- a -> IO a
cont a
x
                                   forall a. (a -> Bool) -> (a -> IO a) -> a -> IO a
loopp a -> Bool
pred a -> IO a
cont a
x'

codescrapL :: Pos -> FilePath -> (Token, Pos, FilePath)
codescrapL Pos
p []                 = (EnumValToken -> FilePath -> Pos -> Token
valueToken EnumValToken
TkTextln FilePath
"" Pos
p,Pos
p,[])
codescrapL Pos
p (Char
x:FilePath
xs) | Char -> Bool
isSpace Char
x = (forall a. Char -> Pos -> (Pos -> a) -> a
updPos'  Char
x Pos
p)  Pos -> FilePath -> (Token, Pos, FilePath)
codescrapL FilePath
xs
                    | Bool
otherwise = let refcol :: Int
refcol = forall p. Position p => p -> Int
column Pos
p
                                      (Pos
p',FilePath
sc,FilePath
rest) = Int -> Pos -> FilePath -> (Pos, FilePath, FilePath)
scrapL Int
refcol Pos
p  (Char
xforall a. a -> [a] -> [a]
:FilePath
xs)
                                  in (EnumValToken -> FilePath -> Pos -> Token
valueToken EnumValToken
TkTextln FilePath
sc Pos
p,Pos
p',FilePath
rest)

scrapL :: Int -> Pos -> FilePath -> (Pos, FilePath, FilePath)
scrapL Int
ref Pos
p (Char
x:FilePath
xs) | Char -> Bool
isSpace Char
x Bool -> Bool -> Bool
|| forall p. Position p => p -> Int
column Pos
p forall a. Ord a => a -> a -> Bool
>= Int
ref =
                          let (Pos
p'',FilePath
sc,FilePath
inp) = forall a. Char -> Pos -> (Pos -> a) -> a
updPos'  Char
x Pos
p (Int -> Pos -> FilePath -> (Pos, FilePath, FilePath)
scrapL Int
ref)  FilePath
xs
                          in  (Pos
p'',Char
xforall a. a -> [a] -> [a]
:FilePath
sc,FilePath
inp)
                    | Bool
otherwise       =(Pos
p,[],Char
xforall a. a -> [a] -> [a]
:FilePath
xs)
scrapL Int
ref Pos
p []     = (Pos
p,[],[])

pNames :: AGParser [Identifier]
pNames :: AGParser [Identifier]
pNames = AGParser [Identifier]
pIdentifiers


-- Insertion is expensive for pCodeBlock in order to prevent infinite inserts.
pCodeBlock ::  AGParser (String,Pos)
pCodeBlock :: AnaParser Input Pair Token Pos (FilePath, Pos)
pCodeBlock   = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> tp -> val -> p (val, Pos)
pCostValToken Int
90 EnumValToken
TkTextln FilePath
"" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"a code block"

pOptQuantifiers :: AGParser [String]
pOptQuantifiers :: AGParser [FilePath]
pOptQuantifiers = (forall (m :: * -> *) a. Monad m => a -> m a
return forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pDoubleColon forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser FilePath
pCodescrap') forall (p :: * -> *) s a. IsParser p s => p a -> a -> p a
`opt` []

pIdentifiers :: AGParser [Identifier]
pIdentifiers :: AGParser [Identifier]
pIdentifiers =  forall (p :: * -> *) s a a1. IsParser p s => p a -> p a1 -> p [a1]
pList1Sep forall (p :: * -> *). IsParser p Token => p FilePath
pComma AGParser Identifier
pIdentifier forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"lowercase identifiers"

pAttrIdentifier :: AGParser Identifier
pAttrIdentifier :: AGParser Identifier
pAttrIdentifier = AGParser Identifier
pIdentifier
                  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Pos
pos -> FilePath -> Pos -> Identifier
Ident FilePath
"imports" Pos
pos) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pIMPORTS
                  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Pos
pos -> FilePath -> Pos -> Identifier
Ident FilePath
"toplevel" Pos
pos) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pTOPLEVEL

pAttrIdentifiers :: AGParser [Identifier]
pAttrIdentifiers :: AGParser [Identifier]
pAttrIdentifiers = forall (p :: * -> *) s a a1. IsParser p s => p a -> p a1 -> p [a1]
pList1Sep forall (p :: * -> *). IsParser p Token => p FilePath
pComma AGParser Identifier
pAttrIdentifier forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"lowercase identifiers"

pUse :: AGParser (String,String,String)
pUse :: AGParser (FilePath, FilePath, FilePath)
pUse = (  (\Pos
u FilePath
x FilePath
y->(FilePath
x,FilePath
y,forall a. Show a => a -> FilePath
show Pos
u)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pUSE forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser FilePath
pCodescrap'  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser FilePath
pCodescrap') forall (p :: * -> *) s a. IsParser p s => p a -> a -> p a
`opt` (FilePath
"",FilePath
"",FilePath
"") forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"USE declaration"

mklower :: String -> String
mklower :: FilePath -> FilePath
mklower (Char
x:FilePath
xs) = Char -> Char
toLower Char
x forall a. a -> [a] -> [a]
: FilePath
xs
mklower []     = []

pSimpleConstructorSet :: AGParser ConstructorSet
pSimpleConstructorSet :: AGParser ConstructorSet
pSimpleConstructorSet =  Identifier -> ConstructorSet
CName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pIdentifierU
                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ConstructorSet
CAll  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$  AGParser Pos
pStar
                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (p :: * -> *) a. IsParser p Token => p a -> p a
pParens AGParser ConstructorSet
pConstructorSet

pConstructorSet :: AGParser ConstructorSet
pConstructorSet :: AGParser ConstructorSet
pConstructorSet =  forall (p :: * -> *) s c.
IsParser p s =>
p (c -> c -> c) -> p c -> p c
pChainl (ConstructorSet -> ConstructorSet -> ConstructorSet
CDifference forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pMinus) AGParser ConstructorSet
term2
  where term2 :: AGParser ConstructorSet
term2 =  forall (p :: * -> *) s c.
IsParser p s =>
p (c -> c -> c) -> p c -> p c
pChainr (forall (p :: * -> *) s a. IsParser p s => a -> p a
pSucceed ConstructorSet -> ConstructorSet -> ConstructorSet
CUnion) AGParser ConstructorSet
term1
        term1 :: AGParser ConstructorSet
term1 =  Identifier -> ConstructorSet
CName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pIdentifierU
             forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ConstructorSet
CAll  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$  AGParser Pos
pStar

pFieldIdentifier :: AGParser Identifier
pFieldIdentifier :: AGParser Identifier
pFieldIdentifier =  AGParser Identifier
pIdentifier
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FilePath -> Pos -> Identifier
Ident FilePath
"lhs"  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pLHS
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FilePath -> Pos -> Identifier
Ident FilePath
"loc"  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pLOC
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FilePath -> Pos -> Identifier
Ident FilePath
"inst" forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pINST

pAugmentToken :: AGParser ()
pAugmentToken :: AGParser ()
pAugmentToken = () forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (AGParser Pos
pAUGMENT forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AGParser Pos
pPlus)

pAttr :: AnaParser Input Pair Token Pos (Identifier, Identifier)
pAttr = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pFieldIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pDot forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pAttrIdentifier

pAttrOrIdent :: AnaParser Input Pair Token Pos Occurrence
pAttrOrIdent
  = Identifier -> Identifier -> Occurrence
OccAttr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pFieldIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* AGParser Pos
pDot forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser Identifier
pAttrIdentifier
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Identifier -> Occurrence
OccRule forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pIdentifier

nl2sp :: Char -> Char
nl2sp :: Char -> Char
nl2sp Char
'\n' = Char
' '
nl2sp Char
'\r' = Char
' '
nl2sp Char
x = Char
x

pVar :: AGParser (Identifier -> (Identifier, Identifier))
pVar :: AGParser (Identifier -> (Identifier, Identifier))
pVar = (\Identifier
att Identifier
fld -> (Identifier
fld,Identifier
att)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pAttrIdentifier

pAssign :: AGParser Bool
pAssign :: AnaParser Input Pair Token Pos Bool
pAssign =  Bool
False forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
key -> p Pos
pReserved FilePath
"="
       forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool
True  forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
key -> p Pos
pReserved FilePath
":="

pRuleSym :: AGParser (Bool, Pos, Bool, Bool)
pRuleSym :: AGParser (Bool, Pos, Bool, Bool)
pRuleSym  =     (\Pos
p -> (Bool
False, Pos
p, Bool
True, Bool
False)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
key -> p Pos
pReserved FilePath
"="
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Pos
p -> (Bool
True,  Pos
p, Bool
True, Bool
False)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
key -> p Pos
pReserved FilePath
":="
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Pos
p -> (Bool
False, Pos
p, Bool
True, Bool
False)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
key -> p Pos
pReserved FilePath
"<-"
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (\Pos
p -> (Bool
False, Pos
p, Bool
True, Bool
True))  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
key -> p Pos
pReserved FilePath
"<<-"

pPattern :: AGParser (a -> (Identifier,Identifier)) -> AGParser (a -> Pattern)
pPattern :: forall a.
AGParser (a -> (Identifier, Identifier)) -> AGParser (a -> Pattern)
pPattern AGParser (a -> (Identifier, Identifier))
pvar = AnaParser Input Pair Token Pos (a -> Pattern)
pPattern2 where
  pPattern0 :: AnaParser Input Pair Token Pos (a -> Pattern)
pPattern0 =  (\Identifier
i [a -> Pattern]
pats a
a -> Identifier -> Patterns -> Pattern
Constr Identifier
i (forall a b. (a -> b) -> [a] -> [b]
map (forall a b. (a -> b) -> a -> b
$ a
a) [a -> Pattern]
pats))
               forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Identifier
pIdentifierU forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a. IsParser p s => p a -> p [a]
pList  AnaParser Input Pair Token Pos (a -> Pattern)
pPattern1
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AnaParser Input Pair Token Pos (a -> Pattern)
pPattern1 forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"a pattern"
  pPattern1 :: AnaParser Input Pair Token Pos (a -> Pattern)
pPattern1 =  AnaParser Input Pair Token Pos (a -> Pattern)
pvariable
           forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AnaParser Input Pair Token Pos (a -> Pattern)
pPattern2
  pvariable :: AnaParser Input Pair Token Pos (a -> Pattern)
pvariable = (\Pattern -> Pattern
ir a -> (Identifier, Identifier)
var a -> Pattern
pat a
a -> case a -> (Identifier, Identifier)
var a
a of (Identifier
fld,Identifier
att) -> Pattern -> Pattern
ir forall a b. (a -> b) -> a -> b
$ Identifier -> Identifier -> Pattern -> Pattern
Alias Identifier
fld Identifier
att (a -> Pattern
pat a
a))
           forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Pattern -> Pattern
Irrefutable forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ AGParser Pos
pTilde) forall (p :: * -> *) s a. IsParser p s => p a -> a -> p a
`opt` forall a. a -> a
id) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AGParser (a -> (Identifier, Identifier))
pvar forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((AGParser Pos
pAt forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> AnaParser Input Pair Token Pos (a -> Pattern)
pPattern1) forall (p :: * -> *) s a. IsParser p s => p a -> a -> p a
`opt` forall a b. a -> b -> a
const (Pos -> Pattern
Underscore Pos
noPos))
  pPattern2 :: AnaParser Input Pair Token Pos (a -> Pattern)
pPattern2 = (forall {t}. Pos -> [t -> Pattern] -> t -> Pattern
mkTuple forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *). IsParser p Token => p Pos
pOParenPos forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (p :: * -> *) s a a1. IsParser p s => p a -> p a1 -> p [a1]
pListSep forall (p :: * -> *). IsParser p Token => p FilePath
pComma AnaParser Input Pair Token Pos (a -> Pattern)
pPattern0 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (p :: * -> *). IsParser p Token => p FilePath
pCParen )
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pos -> Pattern
Underscore) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AGParser Pos
pUScore forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"a pattern"
    where mkTuple :: Pos -> [t -> Pattern] -> t -> Pattern
mkTuple Pos
_ [t -> Pattern
x] t
a = t -> Pattern
x t
a
          mkTuple Pos
p [t -> Pattern]
xs  t
a = Pos -> Patterns -> Pattern
Product Pos
p (forall a b. (a -> b) -> [a] -> [b]
map (forall a b. (a -> b) -> a -> b
$ t
a) [t -> Pattern]
xs)

pCostSym' :: Int# -> s -> p s
pCostSym' Int#
c s
t = forall (p :: * -> *) s. IsParser p s => Int# -> s -> s -> p s
pCostSym Int#
c s
t s
t

pCodescrap' ::  AGParser String
pCodescrap' :: AGParser FilePath
pCodescrap' = forall a b. (a, b) -> a
fst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AnaParser Input Pair Token Pos (FilePath, Pos)
pCodescrap

pCodescrap ::  AGParser (String,Pos)
pCodescrap :: AnaParser Input Pair Token Pos (FilePath, Pos)
pCodescrap   = AnaParser Input Pair Token Pos (FilePath, Pos)
pCodeBlock

pSEM, pATTR, pDATA, pRECORD, pUSE, pLOC,pINCLUDE, pTYPE, pEquals, pColonEquals, pTilde,
      pEXTENDS, --marcos
      pBar, pColon, pLHS,pINST,pSET,pDERIVING,pMinus,pIntersect,pDoubleArrow,pArrow,
      pDot, pUScore, pEXT,pAt,pStar, pSmaller, pWRAPPER, pNOCATAS, pPRAGMA, pMAYBE, pEITHER, pMAP, pINTMAP,
      pMODULE, pATTACH, pUNIQUEREF, pINH, pSYN, pAUGMENT, pPlus, pAROUND, pSEMPRAGMA, pMERGE, pAS, pSELF,
      pIMPORTS, pOPTPRAGMAS, pSmallerEqual, pINTSET, pDATABLOCK, pRECBLOCK
      :: AGParser Pos
pSET :: AGParser Pos
pSET         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"SET"     forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"SET"
pDERIVING :: AGParser Pos
pDERIVING    = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"DERIVING"forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"DERIVING"
pWRAPPER :: AGParser Pos
pWRAPPER     = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"WRAPPER" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"WRAPPER"
pNOCATAS :: AGParser Pos
pNOCATAS     = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"NOCATAS" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"NOCATAS"
pPRAGMA :: AGParser Pos
pPRAGMA      = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"PRAGMA"  forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"PRAGMA"
pSEMPRAGMA :: AGParser Pos
pSEMPRAGMA   = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"SEMPRAGMA" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"SEMPRAGMA"
pATTACH :: AGParser Pos
pATTACH      = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"ATTACH"  forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"ATTACH"
pDATA :: AGParser Pos
pDATA        = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"DATA"    forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"DATA"
pRECORD :: AGParser Pos
pRECORD      = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"RECORD"  forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"RECORD"
pEXT :: AGParser Pos
pEXT         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"EXT"     forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"EXT"
pATTR :: AGParser Pos
pATTR        = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"ATTR"    forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"ATTR"
pSEM :: AGParser Pos
pSEM         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"SEM"     forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"SEM"
pINCLUDE :: AGParser Pos
pINCLUDE     = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"INCLUDE" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"INCLUDE"
pEXTENDS :: AGParser Pos
pEXTENDS     = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"EXTENDS" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"EXTENDS" --marcos
pTYPE :: AGParser Pos
pTYPE        = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"TYPE"    forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"TYPE"
pINH :: AGParser Pos
pINH         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"INH"     forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"INH"
pSYN :: AGParser Pos
pSYN         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"SYN"     forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"SYN"
pCHN :: AGParser Pos
pCHN         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
90 FilePath
"CHN"     forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"CHN"
pMAYBE :: AGParser Pos
pMAYBE       = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"MAYBE"   forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"MAYBE"
pEITHER :: AGParser Pos
pEITHER      = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"EITHER"  forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"EITHER"
pMAP :: AGParser Pos
pMAP         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"MAP"     forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"MAP"
pINTMAP :: AGParser Pos
pINTMAP      = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"INTMAP"  forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"INTMAP"
pINTSET :: AGParser Pos
pINTSET      = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"INTSET"  forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"INTSET"
pUSE :: AGParser Pos
pUSE         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"USE"     forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"USE"
pLOC :: AGParser Pos
pLOC         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"loc"     forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"loc"
pLHS :: AGParser Pos
pLHS         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"lhs"     forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"loc"
pINST :: AGParser Pos
pINST        = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"inst"    forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"inst"
pAt :: AGParser Pos
pAt          = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"@"       forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"@"
pDot :: AGParser Pos
pDot         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"."       forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"."
pUScore :: AGParser Pos
pUScore      = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"_"       forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"_"
pColon :: AGParser Pos
pColon       = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
":"       forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
":"
pDoubleColon :: AGParser Pos
pDoubleColon = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"::"      forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"::"
pEquals :: AGParser Pos
pEquals      = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"="       forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"="
pColonEquals :: AGParser Pos
pColonEquals = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
":="      forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
":="
pTilde :: AGParser Pos
pTilde       = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"~"       forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"~"
pPlus :: AGParser Pos
pPlus        = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"+"       forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"+"
pBar :: AGParser Pos
pBar         = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"|"       forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"|"
pIntersect :: AGParser Pos
pIntersect   = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"/\\"     forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"/\\"
pMinus :: AGParser Pos
pMinus       = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"-"       forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"-"
pDoubleArrow :: AGParser Pos
pDoubleArrow = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"=>"      forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"=>"
pSmallerEqual :: AGParser Pos
pSmallerEqual= forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"<="      forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"<="
pArrow :: AGParser Pos
pArrow       = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"->"      forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"->"
pStar :: AGParser Pos
pStar        = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"*"       forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"*"
pSmaller :: AGParser Pos
pSmaller     = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"<"       forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"<"
pMODULE :: AGParser Pos
pMODULE      = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"MODULE"  forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"MODULE"
pUNIQUEREF :: AGParser Pos
pUNIQUEREF   = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"UNIQUEREF" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"UNIQUEREF"
pAUGMENT :: AGParser Pos
pAUGMENT     = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"AUGMENT" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"AUGMENT"
pAROUND :: AGParser Pos
pAROUND      = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"AROUND" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"AROUND"
pMERGE :: AGParser Pos
pMERGE       = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"MERGE" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"MERGE"
pAS :: AGParser Pos
pAS          = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"AS" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"AS"
pSELF :: AGParser Pos
pSELF        = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"SELF" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"SELF"
pIMPORTS :: AGParser Pos
pIMPORTS     = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"imports" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"imports"
pOPTPRAGMAS :: AGParser Pos
pOPTPRAGMAS  = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"optpragmas" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"optpragmas"
pTOPLEVEL :: AGParser Pos
pTOPLEVEL    = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"toplevel" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"toplevel"
pDATABLOCK :: AGParser Pos
pDATABLOCK   = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"datablock" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"datadecl block"
pRECBLOCK :: AGParser Pos
pRECBLOCK    = forall (p :: * -> *) key tp val.
IsParser p (GenToken key tp val) =>
Int -> key -> p Pos
pCostReserved Int
5  FilePath
"recblock" forall (p :: * -> *) s v. IsParser p s => p v -> FilePath -> p v
<?> FilePath
"recursive block"