    {-|
      Copyright  :  (C) 2012-2016, University of Twente,
                        2017     , Myrtle Software Ltd,
                        2021-2022, QBayLogic B.V.
                        2022     , Google Inc.
      License    :  BSD2 (see the file LICENSE)
      Maintainer :  QBayLogic B.V. <devops@qbaylogic.com>

      Parser definitions for BlackBox templates
    -}

    {-# LANGUAGE OverloadedStrings #-}

    module Clash.Netlist.BlackBox.Parser
      (runParse)
    where

    import           Control.Applicative          ((<|>))
    import           Data.Text.Lazy               (Text, pack, unpack)
    import qualified Data.Text.Lazy               as Text
    import           Text.Trifecta                hiding (Err)
    import           Text.Trifecta.Delta

    import qualified Clash.Signal.Internal        as Signal
    import           Clash.Netlist.BlackBox.Types

    -- | Parse a text as a BlackBoxTemplate, returns a list of errors in case
    -- parsing fails
    runParse :: Text -> Result BlackBoxTemplate
    runParse :: Text -> Result [Element]
    runParse = Parser [Element] -> Delta -> String -> Result [Element]
    forall a. Parser a -> Delta -> String -> Result a
    parseString (Parser [Element]
    pBlackBoxD Parser [Element] -> Parser () -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f a
    <* Parser ()
    forall (m :: Type -> Type). Parsing m => m ()
    eof) (ByteString -> Int64 -> Int64 -> Int64 -> Int64 -> Delta
    Directed ByteString
    "" Int64
    0 Int64
    0 Int64
    0 Int64
    0) (String -> Result [Element])
    -> (Text -> String) -> Text -> Result [Element]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> String
    unpack

    -- | Parse a BlackBoxTemplate (Declarations and Expressions)
    pBlackBoxD :: Parser BlackBoxTemplate
    pBlackBoxD :: Parser [Element]
    pBlackBoxD = Parser Element -> Parser [Element]
    forall a. Parser a -> Parser [a]
    forall (f :: Type -> Type) a. Alternative f => f a -> f [a]
    some Parser Element
    pElement

    -- | Parse a single Template Element
    pElement :: Parser Element
    pElement :: Parser Element
    pElement  =  Parser Element
    pTagD
             Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Text -> Element
    Text (Text -> Element) -> Parser Text -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser Text
    pText
             Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Text -> Element
    Text (Text -> Element) -> Parser Text -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Text
    pack (String -> Text) -> Parser String -> Parser Text
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ ")

    -- | Parse the Text part of a Template
    pText :: Parser Text
    pText :: Parser Text
    pText = String -> Text
    pack (String -> Text) -> Parser String -> Parser Text
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser Char -> Parser String
    forall a. Parser a -> Parser [a]
    forall (f :: Type -> Type) a. Alternative f => f a -> f [a]
    some (Char -> Char -> Parser Char
    forall (m :: Type -> Type). CharParsing m => Char -> Char -> m Char
    satisfyRange Char
    '\000' Char
    '\125')

    pEdge :: Parser Signal.ActiveEdge
    pEdge :: Parser ActiveEdge
    pEdge =
      (ActiveEdge -> Parser ActiveEdge
    forall a. a -> Parser a
    forall (f :: Type -> Type) a. Applicative f => a -> f a
    pure ActiveEdge
    Signal.Rising Parser ActiveEdge -> Parser String -> Parser ActiveEdge
    forall a b. Parser a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f a
    <* String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "Rising") Parser ActiveEdge -> Parser ActiveEdge -> Parser ActiveEdge
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|>
      (ActiveEdge -> Parser ActiveEdge
    forall a. a -> Parser a
    forall (f :: Type -> Type) a. Applicative f => a -> f a
    pure ActiveEdge
    Signal.Falling Parser ActiveEdge -> Parser String -> Parser ActiveEdge
    forall a b. Parser a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f a
    <* String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "Falling")

    -- | Parse a Declaration or Expression element
    pTagD :: Parser Element
    pTagD :: Parser Element
    pTagD =  Element -> [Element] -> [Element] -> Element
    IF (Element -> [Element] -> [Element] -> Element)
    -> Parser Element -> Parser ([Element] -> [Element] -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "~IF" Parser String -> Parser Element -> Parser Element
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Element
    pTagE)
                Parser ([Element] -> [Element] -> Element)
    -> Parser [Element] -> Parser ([Element] -> Element)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> (Parser ()
    forall (m :: Type -> Type). CharParsing m => m ()
    spaces Parser () -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~THEN" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element]
    pBlackBoxD))
                Parser ([Element] -> Element) -> Parser [Element] -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ELSE" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> [Element] -> Parser [Element] -> Parser [Element]
    forall (m :: Type -> Type) a. Alternative m => a -> m a -> m a
    option ([Text -> Element
    Text Text
    ""]) Parser [Element]
    pBlackBoxD Parser [Element] -> Parser String -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f a
    <* String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~FI")
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Decl -> Element
    Component (Decl -> Element) -> Parser Decl -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser Decl
    pDecl
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Parser Element
    pTagE

    -- | Parse a Declaration
    pDecl :: Parser Decl
    pDecl :: Parser Decl
    pDecl = Int -> Int -> [([Element], [Element])] -> Decl
    Decl (Int -> Int -> [([Element], [Element])] -> Decl)
    -> Parser Int -> Parser (Int -> [([Element], [Element])] -> Decl)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "~INST" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural') Parser (Int -> [([Element], [Element])] -> Decl)
    -> Parser Int -> Parser ([([Element], [Element])] -> Decl)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Int -> Parser Int
    forall a. a -> Parser a
    forall (f :: Type -> Type) a. Applicative f => a -> f a
    pure Int
    0 Parser ([([Element], [Element])] -> Decl)
    -> Parser [([Element], [Element])] -> Parser Decl
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*>
            ((:) (([Element], [Element])
     -> [([Element], [Element])] -> [([Element], [Element])])
    -> Parser ([Element], [Element])
    -> Parser ([([Element], [Element])] -> [([Element], [Element])])
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser ([Element], [Element])
    pOutput Parser ([([Element], [Element])] -> [([Element], [Element])])
    -> Parser [([Element], [Element])]
    -> Parser [([Element], [Element])]
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser ([Element], [Element]) -> Parser [([Element], [Element])]
    forall a. Parser a -> Parser [a]
    forall (f :: Type -> Type) a. Alternative f => f a -> f [a]
    many Parser ([Element], [Element])
    pInput) Parser Decl -> Parser String -> Parser Decl
    forall a b. Parser a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f a
    <* String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~INST"

    -- | Parse the output tag of Declaration
    pOutput :: Parser (BlackBoxTemplate,BlackBoxTemplate)
    pOutput :: Parser ([Element], [Element])
    pOutput = String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "~OUTPUT" Parser String -> Parser String -> Parser String
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "<=" Parser String
    -> Parser ([Element], [Element]) -> Parser ([Element], [Element])
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> ((,) ([Element] -> [Element] -> ([Element], [Element]))
    -> Parser [Element] -> Parser ([Element] -> ([Element], [Element]))
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Parser [Element]
    pBlackBoxE Parser [Element] -> Parser String -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f a
    <* String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "~") Parser ([Element] -> ([Element], [Element]))
    -> Parser [Element] -> Parser ([Element], [Element])
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser [Element]
    pBlackBoxE) Parser ([Element], [Element])
    -> Parser String -> Parser ([Element], [Element])
    forall a b. Parser a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f a
    <* String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "~"

    -- | Parse the input tag of Declaration
    pInput :: Parser (BlackBoxTemplate,BlackBoxTemplate)
    pInput :: Parser ([Element], [Element])
    pInput = String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "~INPUT" Parser String -> Parser String -> Parser String
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "<=" Parser String
    -> Parser ([Element], [Element]) -> Parser ([Element], [Element])
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> ((,) ([Element] -> [Element] -> ([Element], [Element]))
    -> Parser [Element] -> Parser ([Element] -> ([Element], [Element]))
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Parser [Element]
    pBlackBoxE Parser [Element] -> Parser String -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f a
    <* String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "~") Parser ([Element] -> ([Element], [Element]))
    -> Parser [Element] -> Parser ([Element], [Element])
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser [Element]
    pBlackBoxE) Parser ([Element], [Element])
    -> Parser String -> Parser ([Element], [Element])
    forall a b. Parser a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f a
    <* String -> Parser String
    forall (m :: Type -> Type). TokenParsing m => String -> m String
    symbol String
    "~"

    -- | Parse an Expression element
    pTagE :: Parser Element
    pTagE :: Parser Element
    pTagE =  Element
    Result            Element -> Parser String -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$  String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~RESULT"
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Int -> Element
    ArgGen            (Int -> Int -> Element) -> Parser Int -> Parser (Int -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ARGN" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural') Parser (Int -> Element) -> Parser Int -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural'
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    Arg               (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ARG" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    Const             (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~CONST" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    Lit               (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~LIT" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    Name              (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~NAME" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> [Element] -> Int -> Element
    ToVar             ([Element] -> Int -> Element)
    -> Parser [Element] -> Parser (Int -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    forall (m :: Type -> Type) a. Parsing m => m a -> m a
    try (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~VAR" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigDorEmpty) Parser (Int -> Element) -> Parser Int -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural'
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (Text -> Int -> Element
    Sym Text
    Text.empty)  (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~SYM" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Maybe Int -> Element
    Typ Maybe Int
    forall a. Maybe a
    Nothing       Element -> Parser String -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$  String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~TYPO"
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (Maybe Int -> Element
    Typ (Maybe Int -> Element) -> (Int -> Maybe Int) -> Int -> Element
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Maybe Int
    forall a. a -> Maybe a
    Just)      (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    forall (m :: Type -> Type) a. Parsing m => m a -> m a
    try (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~TYP" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Maybe Int -> Element
    TypM Maybe Int
    forall a. Maybe a
    Nothing      Element -> Parser String -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$  String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~TYPMO"
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (Maybe Int -> Element
    TypM (Maybe Int -> Element) -> (Int -> Maybe Int) -> Int -> Element
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Maybe Int
    forall a. a -> Maybe a
    Just)     (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~TYPM" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Maybe Int -> Element
    Err Maybe Int
    forall a. Maybe a
    Nothing       Element -> Parser String -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$  String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ERRORO"
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (Maybe Int -> Element
    Err (Maybe Int -> Element) -> (Int -> Maybe Int) -> Int -> Element
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Maybe Int
    forall a. a -> Maybe a
    Just)      (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ERROR" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element -> Element
    TypElem           (Element -> Element) -> Parser Element -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~TYPEL" Parser String -> Parser Element -> Parser Element
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE)
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element -> Element
    IndexType         (Element -> Element) -> Parser Element -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~INDEXTYPE" Parser String -> Parser Element -> Parser Element
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE)
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element
    CompName          Element -> Parser String -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$  String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~COMPNAME"
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    IncludeName       (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~INCLUDENAME" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element -> Element
    Size              (Element -> Element) -> Parser Element -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~SIZE" Parser String -> Parser Element -> Parser Element
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE)
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element -> Element
    Length            (Element -> Element) -> Parser Element -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~LENGTH" Parser String -> Parser Element -> Parser Element
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE)
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element -> Element
    Depth             (Element -> Element) -> Parser Element -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~DEPTH" Parser String -> Parser Element -> Parser Element
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE)
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element -> Element
    MaxIndex          (Element -> Element) -> Parser Element -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~MAXINDEX" Parser String -> Parser Element -> Parser Element
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE)
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element -> Element
    FilePath          (Element -> Element) -> Parser Element -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~FILE" Parser String -> Parser Element -> Parser Element
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE)
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Bool -> Element
    Gen               (Bool -> Element) -> Parser Bool -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Bool
    True Bool -> Parser String -> Parser Bool
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$ String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~GENERATE")
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Bool -> Element
    Gen               (Bool -> Element) -> Parser Bool -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Bool
    False Bool -> Parser String -> Parser Bool
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$ String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ENDGENERATE")
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> ([Element] -> Maybe Int -> Element
    `SigD` Maybe Int
    forall a. Maybe a
    Nothing)  ([Element] -> Element) -> Parser [Element] -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~SIGDO" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigD)
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> [Element] -> Maybe Int -> Element
    SigD              ([Element] -> Maybe Int -> Element)
    -> Parser [Element] -> Parser (Maybe Int -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~SIGD" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigD) Parser (Maybe Int -> Element)
    -> Parser (Maybe Int) -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> (Int -> Maybe Int
    forall a. a -> Maybe a
    Just (Int -> Maybe Int) -> Parser Int -> Parser (Maybe Int)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural'))
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element
    IW64              Element -> Parser String -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$  String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~IW64"
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element -> Element -> Element
    CmpLE             (Element -> Element -> Element)
    -> Parser Element -> Parser (Element -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    forall (m :: Type -> Type) a. Parsing m => m a -> m a
    try (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~CMPLE" Parser String -> Parser Element -> Parser Element
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE) Parser (Element -> Element) -> Parser Element -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (HdlSyn -> Element
    HdlSyn HdlSyn
    Vivado)   Element -> Parser String -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$  String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~VIVADO"
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (HdlSyn -> Element
    HdlSyn HdlSyn
    Other)    Element -> Parser String -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$  String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~OTHERSYN"
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (Bool -> [Element] -> Element -> Element
    BV Bool
    True)         ([Element] -> Element -> Element)
    -> Parser [Element] -> Parser (Element -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~TOBV" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigD) Parser (Element -> Element) -> Parser Element -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (Bool -> [Element] -> Element -> Element
    BV Bool
    False)        ([Element] -> Element -> Element)
    -> Parser [Element] -> Parser (Element -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~FROMBV" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigD) Parser (Element -> Element) -> Parser Element -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element -> Int -> Element
    Sel               (Element -> Int -> Element)
    -> Parser Element -> Parser (Int -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~SEL" Parser String -> Parser Element -> Parser Element
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Element -> Parser Element
    forall a. Parser a -> Parser a
    brackets' Parser Element
    pTagE) Parser (Int -> Element) -> Parser Int -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural'
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    IsLit             (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ISLIT" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    IsVar             (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ISVAR" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    IsScalar          (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ISSCALAR" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    IsActiveHigh      (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ISACTIVEHIGH" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    IsActiveEnable    (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ISACTIVEENABLE" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    IsUndefined       (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ISUNDEFINED" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> [Element] -> Int -> Element
    StrCmp            ([Element] -> Int -> Element)
    -> Parser [Element] -> Parser (Int -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~STRCMP" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigD) Parser (Int -> Element) -> Parser Int -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural'
         -- Parse ~OUTPUTWIREREG for backwards compatibility
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    OutputUsage       (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~OUTPUTWIREREG" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    OutputUsage       (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~OUTPUTUSAGE" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> [Element] -> Int -> Element
    GenSym            ([Element] -> Int -> Element)
    -> Parser [Element] -> Parser (Int -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~GENSYM" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigD) Parser (Int -> Element) -> Parser Int -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural'
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> [Element] -> [Element] -> Element
    Template          ([Element] -> [Element] -> Element)
    -> Parser [Element] -> Parser ([Element] -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~TEMPLATE" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigD) Parser ([Element] -> Element) -> Parser [Element] -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigD
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> [Element] -> [Element] -> Element
    Repeat            ([Element] -> [Element] -> Element)
    -> Parser [Element] -> Parser ([Element] -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~REPEAT" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigD) Parser ([Element] -> Element) -> Parser [Element] -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigD
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> [Element] -> Element
    DevNull           ([Element] -> Element) -> Parser [Element] -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~DEVNULL" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' Parser [Element]
    pSigD)
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> [Element] -> Element
    And               ([Element] -> Element) -> Parser [Element] -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~AND" Parser String -> Parser [Element] -> Parser [Element]
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a
    brackets' (Parser Element -> Parser [Element]
    forall (m :: Type -> Type) a. TokenParsing m => m a -> m [a]
    commaSep Parser Element
    pTagE))
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    Vars              (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~VARS" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')

         -- Domain attributes:
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    Tag               (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~TAG" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    Period            (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~PERIOD" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> ActiveEdge -> Int -> Element
    ActiveEdge        (ActiveEdge -> Int -> Element)
    -> Parser ActiveEdge -> Parser (Int -> Element)
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ACTIVEEDGE" Parser String -> Parser ActiveEdge -> Parser ActiveEdge
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser ActiveEdge -> Parser ActiveEdge
    forall (m :: Type -> Type) a. TokenParsing m => m a -> m a
    brackets Parser ActiveEdge
    pEdge) Parser (Int -> Element) -> Parser Int -> Parser Element
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: Type -> Type) a b.
    Applicative f =>
    f (a -> b) -> f a -> f b
    <*> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural'
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    IsSync            (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ISSYNC" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Int -> Element
    IsInitDefined     (Int -> Element) -> Parser Int -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~ISINITDEFINED" Parser String -> Parser Int -> Parser Int
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser Int -> Parser Int
    forall a. Parser a -> Parser a
    brackets' Parser Int
    forall (m :: Type -> Type). TokenParsing m => m Int
    natural')
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element
    CtxName           Element -> Parser String -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$  String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~CTXNAME"
         Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Element
    LongestPeriod     Element -> Parser String -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$  String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "~LONGESTPERIOD"

    natural' :: TokenParsing m => m Int
    natural' :: forall (m :: Type -> Type). TokenParsing m => m Int
    natural' = (Integer -> Int) -> m Integer -> m Int
    forall a b. (a -> b) -> m a -> m b
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    fmap Integer -> Int
    forall a. Num a => Integer -> a
    fromInteger m Integer
    forall (m :: Type -> Type). TokenParsing m => m Integer
    natural

    -- | Parse a bracketed text
    brackets' :: Parser a -> Parser a
    brackets' :: forall a. Parser a -> Parser a
    brackets' Parser a
    p = Char -> Parser Char
    forall (m :: Type -> Type). CharParsing m => Char -> m Char
    char Char
    '[' Parser Char -> Parser a -> Parser a
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
    *> Parser a
    p Parser a -> Parser Char -> Parser a
    forall a b. Parser a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f a
    <* Char -> Parser Char
    forall (m :: Type -> Type). CharParsing m => Char -> m Char
    char Char
    ']'

    -- | Parse the expression part of Blackbox Templates
    pBlackBoxE :: Parser BlackBoxTemplate
    pBlackBoxE :: Parser [Element]
    pBlackBoxE = Parser Element -> Parser [Element]
    forall a. Parser a -> Parser [a]
    forall (f :: Type -> Type) a. Alternative f => f a -> f [a]
    some Parser Element
    pElemE

    -- | Parse an Expression or Text
    pElemE :: Parser Element
    pElemE :: Parser Element
    pElemE = Parser Element
    pTagE
          Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Text -> Element
    Text (Text -> Element) -> Parser Text -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser Text
    pText

    -- | Parse SigD
    pSigD :: Parser [Element]
    pSigD :: Parser [Element]
    pSigD = Parser Element -> Parser [Element]
    forall a. Parser a -> Parser [a]
    forall (f :: Type -> Type) a. Alternative f => f a -> f [a]
    some (Parser Element
    pTagE Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (Text -> Element
    Text (String -> Text
    pack String
    "[") Element -> Parser Text -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$ (String -> Text
    pack (String -> Text) -> Parser String -> Parser Text
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "[\\"))
                        Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (Text -> Element
    Text (String -> Text
    pack String
    "]") Element -> Parser Text -> Parser Element
    forall a b. a -> Parser b -> Parser a
    forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
    <$ (String -> Text
    pack (String -> Text) -> Parser String -> Parser Text
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> String -> Parser String
    forall (m :: Type -> Type). CharParsing m => String -> m String
    string String
    "\\]"))
                        Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (Text -> Element
    Text (Text -> Element) -> Parser Text -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Text
    pack (String -> Text) -> Parser String -> Parser Text
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser Char -> Parser String
    forall a. Parser a -> Parser [a]
    forall (f :: Type -> Type) a. Alternative f => f a -> f [a]
    some (Char -> Char -> Parser Char
    forall (m :: Type -> Type). CharParsing m => Char -> Char -> m Char
    satisfyRange Char
    '\000' Char
    '\90')))
                        Parser Element -> Parser Element -> Parser Element
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> (Text -> Element
    Text (Text -> Element) -> Parser Text -> Parser Element
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String -> Text
    pack (String -> Text) -> Parser String -> Parser Text
    forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser Char -> Parser String
    forall a. Parser a -> Parser [a]
    forall (f :: Type -> Type) a. Alternative f => f a -> f [a]
    some (Char -> Char -> Parser Char
    forall (m :: Type -> Type). CharParsing m => Char -> Char -> m Char
    satisfyRange Char
    '\94' Char
    '\125'))))

    pSigDorEmpty :: Parser [Element]
    pSigDorEmpty :: Parser [Element]
    pSigDorEmpty = Parser [Element]
    pSigD Parser [Element] -> Parser [Element] -> Parser [Element]
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
    <|> Parser [Element]
    forall a. Monoid a => a
    mempty