-- |
-- Module      : Verismith.Verilog.Parser
-- Description : Minimal Verilog parser to reconstruct the AST.
-- Copyright   : (c) 2019-2022, Yann Herklotz
-- License     : GPL-3
-- Maintainer  : yann [at] yannherklotz [dot] com
-- Stability   : experimental
-- Portability : POSIX
--
-- Minimal Verilog parser to reconstruct the AST. This parser does not support the
-- whole Verilog syntax, as the AST does not support it either.
module Verismith.Verilog.Parser
  ( -- * Parser
    parseVerilog,
    parseVerilogFile,
    parseSourceInfoFile,

    -- ** Internal parsers
    parseEvent,
    parseStatement,
    parseModItem,
    parseModDecl,
    Parser,
  )
where

import Control.Lens
import Control.Monad (void)
import Data.Bifunctor (bimap)
import Data.Bits
import Data.Functor (($>))
import Data.Functor.Identity (Identity)
import Data.List (isInfixOf, isPrefixOf, null)
import Data.List.NonEmpty (NonEmpty (..))
import qualified Data.Map.Strict as Map
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Text.Parsec hiding (satisfy)
import Text.Parsec.Expr
import Verismith.Utils
import Verismith.Verilog.AST
import Verismith.Verilog.BitVec
import Verismith.Verilog.Internal
import Verismith.Verilog.Lex
import Verismith.Verilog.Preprocess
import Verismith.Verilog.Token

type Parser = Parsec [Token] ()

type ParseOperator = Operator [Token] () Identity

data Decimal = Decimal Int Integer

instance Num Decimal where
  (Decimal Int
sa Integer
na) + :: Decimal -> Decimal -> Decimal
+ (Decimal Int
sb Integer
nb) = Int -> Integer -> Decimal
Decimal (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
sa Int
sb) (Integer
na Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
nb)
  (Decimal Int
sa Integer
na) - :: Decimal -> Decimal -> Decimal
- (Decimal Int
sb Integer
nb) = Int -> Integer -> Decimal
Decimal (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
sa Int
sb) (Integer
na Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
nb)
  (Decimal Int
sa Integer
na) * :: Decimal -> Decimal -> Decimal
* (Decimal Int
sb Integer
nb) = Int -> Integer -> Decimal
Decimal (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
sa Int
sb) (Integer
na Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
nb)
  negate :: Decimal -> Decimal
negate (Decimal Int
s Integer
n) = Int -> Integer -> Decimal
Decimal Int
s (Integer -> Decimal) -> Integer -> Decimal
forall a b. (a -> b) -> a -> b
$ Integer -> Integer
forall a. Num a => a -> a
negate Integer
n
  abs :: Decimal -> Decimal
abs (Decimal Int
s Integer
n) = Int -> Integer -> Decimal
Decimal Int
s (Integer -> Decimal) -> Integer -> Decimal
forall a b. (a -> b) -> a -> b
$ Integer -> Integer
forall a. Num a => a -> a
abs Integer
n
  signum :: Decimal -> Decimal
signum (Decimal Int
s Integer
n) = Int -> Integer -> Decimal
Decimal Int
s (Integer -> Decimal) -> Integer -> Decimal
forall a b. (a -> b) -> a -> b
$ Integer -> Integer
forall a. Num a => a -> a
signum Integer
n
  fromInteger :: Integer -> Decimal
fromInteger = Int -> Integer -> Decimal
Decimal Int
32 (Integer -> Decimal) -> (Integer -> Integer) -> Integer -> Decimal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer
forall a. Num a => Integer -> a
fromInteger

-- | This parser succeeds whenever the given predicate returns true when called
-- with parsed `Token`. Same as 'Text.Parsec.Char.satisfy'.
satisfy :: (Token -> Bool) -> Parser TokenName
satisfy :: (Token -> Bool) -> Parser TokenName
satisfy Token -> Bool
f = (Token -> [Char])
-> (SourcePos -> Token -> [Token] -> SourcePos)
-> (Token -> Maybe TokenName)
-> Parser TokenName
forall s (m :: * -> *) t a u.
Stream s m t =>
(t -> [Char])
-> (SourcePos -> t -> s -> SourcePos)
-> (t -> Maybe a)
-> ParsecT s u m a
tokenPrim Token -> [Char]
forall a. Show a => a -> [Char]
show SourcePos -> Token -> [Token] -> SourcePos
nextPos Token -> Maybe TokenName
tokeq
  where
    tokeq :: Token -> Maybe TokenName
    tokeq :: Token -> Maybe TokenName
tokeq t :: Token
t@(Token TokenName
t' [Char]
_ Position
_) = if Token -> Bool
f Token
t then TokenName -> Maybe TokenName
forall a. a -> Maybe a
Just TokenName
t' else Maybe TokenName
forall a. Maybe a
Nothing

satisfy' :: (Token -> Maybe a) -> Parser a
satisfy' :: forall a. (Token -> Maybe a) -> Parser a
satisfy' = (Token -> [Char])
-> (SourcePos -> Token -> [Token] -> SourcePos)
-> (Token -> Maybe a)
-> ParsecT [Token] () Identity a
forall s (m :: * -> *) t a u.
Stream s m t =>
(t -> [Char])
-> (SourcePos -> t -> s -> SourcePos)
-> (t -> Maybe a)
-> ParsecT s u m a
tokenPrim Token -> [Char]
forall a. Show a => a -> [Char]
show SourcePos -> Token -> [Token] -> SourcePos
nextPos

nextPos :: SourcePos -> Token -> [Token] -> SourcePos
nextPos :: SourcePos -> Token -> [Token] -> SourcePos
nextPos SourcePos
pos Token
_ (Token TokenName
_ [Char]
_ (Position [Char]
_ Int
l Int
c) : [Token]
_) =
  SourcePos -> Int -> SourcePos
setSourceColumn (SourcePos -> Int -> SourcePos
setSourceLine SourcePos
pos Int
l) Int
c
nextPos SourcePos
pos Token
_ [] = SourcePos
pos

-- | Parses given `TokenName`.
tok :: TokenName -> Parser TokenName
tok :: TokenName -> Parser TokenName
tok TokenName
t = (Token -> Bool) -> Parser TokenName
satisfy (\(Token TokenName
t' [Char]
_ Position
_) -> TokenName
t' TokenName -> TokenName -> Bool
forall a. Eq a => a -> a -> Bool
== TokenName
t) Parser TokenName -> [Char] -> Parser TokenName
forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> TokenName -> [Char]
forall a. Show a => a -> [Char]
show TokenName
t

-- | Parse without returning the `TokenName`.
tok' :: TokenName -> Parser ()
tok' :: TokenName -> Parser ()
tok' TokenName
p = Parser TokenName -> Parser ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Parser TokenName -> Parser ()) -> Parser TokenName -> Parser ()
forall a b. (a -> b) -> a -> b
$ TokenName -> Parser TokenName
tok TokenName
p

parens :: Parser a -> Parser a
parens :: forall a. Parser a -> Parser a
parens = Parser TokenName
-> Parser TokenName
-> ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity a
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (TokenName -> Parser TokenName
tok TokenName
SymParenL) (TokenName -> Parser TokenName
tok TokenName
SymParenR)

brackets :: Parser a -> Parser a
brackets :: forall a. Parser a -> Parser a
brackets = Parser TokenName
-> Parser TokenName
-> ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity a
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (TokenName -> Parser TokenName
tok TokenName
SymBrackL) (TokenName -> Parser TokenName
tok TokenName
SymBrackR)

braces :: Parser a -> Parser a
braces :: forall a. Parser a -> Parser a
braces = Parser TokenName
-> Parser TokenName
-> ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity a
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (TokenName -> Parser TokenName
tok TokenName
SymBraceL) (TokenName -> Parser TokenName
tok TokenName
SymBraceR)

sBinOp :: BinaryOperator -> Expr -> Expr -> Expr
sBinOp :: BinaryOperator -> Expr -> Expr -> Expr
sBinOp = (Expr -> BinaryOperator -> Expr -> Expr)
-> BinaryOperator -> Expr -> Expr -> Expr
forall {t} {t} {t}. (t -> t -> t) -> t -> t -> t
sOp Expr -> BinaryOperator -> Expr -> Expr
BinOp where sOp :: (t -> t -> t) -> t -> t -> t
sOp t -> t -> t
f t
b t
a = t -> t -> t
f t
a t
b

parseExpr' :: Parser Expr
parseExpr' :: Parser Expr
parseExpr' = OperatorTable [Token] () Identity Expr
-> Parser Expr -> Parser Expr
forall s (m :: * -> *) t u a.
Stream s m t =>
OperatorTable s u m a -> ParsecT s u m a -> ParsecT s u m a
buildExpressionParser OperatorTable [Token] () Identity Expr
parseTable Parser Expr
parseTerm Parser Expr -> [Char] -> Parser Expr
forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"expr"

decToExpr :: Decimal -> Expr
decToExpr :: Decimal -> Expr
decToExpr (Decimal Int
s Integer
n) = BitVec -> Expr
Number (BitVec -> Expr) -> BitVec -> Expr
forall a b. (a -> b) -> a -> b
$ Int -> Integer -> BitVec
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec Int
s Integer
n

-- | Parse a Number depending on if it is in a hex or decimal form. Octal and
-- binary are not supported yet.
parseNum :: Parser Expr
parseNum :: Parser Expr
parseNum = Decimal -> Expr
decToExpr (Decimal -> Expr)
-> ParsecT [Token] () Identity Decimal -> Parser Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Token] () Identity Decimal
number

parseVar :: Parser Expr
parseVar :: Parser Expr
parseVar = Identifier -> Expr
Id (Identifier -> Expr)
-> ParsecT [Token] () Identity Identifier -> Parser Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Token] () Identity Identifier
identifier

parseVecSelect :: Parser Expr
parseVecSelect :: Parser Expr
parseVecSelect = do
  Identifier
i <- ParsecT [Token] () Identity Identifier
identifier
  Expr
expr <- Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
brackets Parser Expr
parseExpr
  Expr -> Parser Expr
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Expr -> Parser Expr) -> Expr -> Parser Expr
forall a b. (a -> b) -> a -> b
$ Identifier -> Expr -> Expr
VecSelect Identifier
i Expr
expr

parseRangeSelect :: Parser Expr
parseRangeSelect :: Parser Expr
parseRangeSelect = do
  Identifier
i <- ParsecT [Token] () Identity Identifier
identifier
  Range
range <- Parser Range
parseRange
  Expr -> Parser Expr
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Expr -> Parser Expr) -> Expr -> Parser Expr
forall a b. (a -> b) -> a -> b
$ Identifier -> Range -> Expr
RangeSelect Identifier
i Range
range

systemFunc :: Parser String
systemFunc :: Parser [Char]
systemFunc = (Token -> Maybe [Char]) -> Parser [Char]
forall a. (Token -> Maybe a) -> Parser a
satisfy' Token -> Maybe [Char]
matchId
  where
    matchId :: Token -> Maybe [Char]
matchId (Token TokenName
IdSystem [Char]
s Position
_) = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
s
    matchId Token
_ = Maybe [Char]
forall a. Maybe a
Nothing

parseFun :: Parser Expr
parseFun :: Parser Expr
parseFun = do
  [Char]
f <- Parser [Char]
systemFunc
  Expr
expr <- Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
parens Parser Expr
parseExpr
  Expr -> Parser Expr
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Expr -> Parser Expr) -> Expr -> Parser Expr
forall a b. (a -> b) -> a -> b
$ Identifier -> Expr -> Expr
Appl (Text -> Identifier
Identifier (Text -> Identifier) -> Text -> Identifier
forall a b. (a -> b) -> a -> b
$ [Char] -> Text
T.pack [Char]
f) Expr
expr

parserNonEmpty :: [a] -> Parser (NonEmpty a)
parserNonEmpty :: forall a. [a] -> Parser (NonEmpty a)
parserNonEmpty (a
a : [a]
b) = NonEmpty a -> ParsecT [Token] () Identity (NonEmpty a)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty a -> ParsecT [Token] () Identity (NonEmpty a))
-> NonEmpty a -> ParsecT [Token] () Identity (NonEmpty a)
forall a b. (a -> b) -> a -> b
$ a
a a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
b
parserNonEmpty [] = [Char] -> ParsecT [Token] () Identity (NonEmpty a)
forall a. [Char] -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"Concatenation cannot be empty."

parseTerm :: Parser Expr
parseTerm :: Parser Expr
parseTerm =
  Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
parens Parser Expr
parseExpr
    Parser Expr -> Parser Expr -> Parser Expr
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (NonEmpty Expr -> Expr
Concat (NonEmpty Expr -> Expr)
-> ParsecT [Token] () Identity (NonEmpty Expr) -> Parser Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser [Expr] -> Parser [Expr]
forall a. Parser a -> Parser a
braces (Parser Expr -> Parser [Expr]
forall a. Parser a -> Parser [a]
commaSep Parser Expr
parseExpr) Parser [Expr]
-> ([Expr] -> ParsecT [Token] () Identity (NonEmpty Expr))
-> ParsecT [Token] () Identity (NonEmpty Expr)
forall a b.
ParsecT [Token] () Identity a
-> (a -> ParsecT [Token] () Identity b)
-> ParsecT [Token] () Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [Expr] -> ParsecT [Token] () Identity (NonEmpty Expr)
forall a. [a] -> Parser (NonEmpty a)
parserNonEmpty))
    Parser Expr -> Parser Expr -> Parser Expr
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Expr
parseFun
    Parser Expr -> Parser Expr -> Parser Expr
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Expr
parseNum
    Parser Expr -> Parser Expr -> Parser Expr
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Expr -> Parser Expr
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser Expr
parseVecSelect
    Parser Expr -> Parser Expr -> Parser Expr
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Expr -> Parser Expr
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser Expr
parseRangeSelect
    Parser Expr -> Parser Expr -> Parser Expr
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Expr
parseVar
    Parser Expr -> [Char] -> Parser Expr
forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"simple expr"

-- | Parses the ternary conditional operator. It will behave in a right
-- associative way.
parseCond :: Expr -> Parser Expr
parseCond :: Expr -> Parser Expr
parseCond Expr
e = do
  TokenName -> Parser ()
tok' TokenName
SymQuestion
  Expr
expr <- Parser Expr
parseExpr
  TokenName -> Parser ()
tok' TokenName
SymColon
  Expr -> Expr -> Expr -> Expr
Cond Expr
e Expr
expr (Expr -> Expr) -> Parser Expr -> Parser Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
parseExpr

parseExpr :: Parser Expr
parseExpr :: Parser Expr
parseExpr = do
  Expr
e <- Parser Expr
parseExpr'
  Expr -> Parser Expr -> Parser Expr
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Expr
e (Parser Expr -> Parser Expr)
-> (Parser Expr -> Parser Expr) -> Parser Expr -> Parser Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser Expr -> Parser Expr
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Parser Expr -> Parser Expr) -> Parser Expr -> Parser Expr
forall a b. (a -> b) -> a -> b
$ Expr -> Parser Expr
parseCond Expr
e

parseConstExpr :: Parser ConstExpr
parseConstExpr :: Parser ConstExpr
parseConstExpr = (Expr -> ConstExpr) -> Parser Expr -> Parser ConstExpr
forall a b.
(a -> b)
-> ParsecT [Token] () Identity a -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr -> ConstExpr
exprToConst Parser Expr
parseExpr

-- | Table of binary and unary operators that encode the right precedence for
-- each.
parseTable :: [[ParseOperator Expr]]
parseTable :: OperatorTable [Token] () Identity Expr
parseTable =
  [ [TokenName -> (Expr -> Expr) -> ParseOperator Expr
forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
SymBang (UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnLNot), TokenName -> (Expr -> Expr) -> ParseOperator Expr
forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
SymTildy (UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnNot)],
    [ TokenName -> (Expr -> Expr) -> ParseOperator Expr
forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
SymAmp (UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnAnd),
      TokenName -> (Expr -> Expr) -> ParseOperator Expr
forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
SymBar (UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnOr),
      TokenName -> (Expr -> Expr) -> ParseOperator Expr
forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
SymTildyAmp (UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnNand),
      TokenName -> (Expr -> Expr) -> ParseOperator Expr
forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
SymTildyBar (UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnNor),
      TokenName -> (Expr -> Expr) -> ParseOperator Expr
forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
SymHat (UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnXor),
      TokenName -> (Expr -> Expr) -> ParseOperator Expr
forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
SymTildyHat (UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnNxor),
      TokenName -> (Expr -> Expr) -> ParseOperator Expr
forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
SymHatTildy (UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnNxorInv)
    ],
    [TokenName -> (Expr -> Expr) -> ParseOperator Expr
forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
SymPlus (UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnPlus), TokenName -> (Expr -> Expr) -> ParseOperator Expr
forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
SymDash (UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnMinus)],
    [TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymAsterAster (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinPower) Assoc
AssocRight],
    [ TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymAster (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinTimes) Assoc
AssocLeft,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymSlash (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinDiv) Assoc
AssocLeft,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymPercent (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinMod) Assoc
AssocLeft
    ],
    [ TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymPlus (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinPlus) Assoc
AssocLeft,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymDash (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinMinus) Assoc
AssocLeft
    ],
    [ TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymLtLt (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinLSL) Assoc
AssocLeft,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymGtGt (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinLSR) Assoc
AssocLeft
    ],
    [ TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymLtLtLt (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinASL) Assoc
AssocLeft,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymGtGtGt (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinASR) Assoc
AssocLeft
    ],
    [ TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymLt (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinLT) Assoc
AssocNone,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymGt (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinGT) Assoc
AssocNone,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymLtEq (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinLEq) Assoc
AssocNone,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymGtEq (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinGEq) Assoc
AssocNone
    ],
    [ TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymEqEq (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinEq) Assoc
AssocNone,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymBangEq (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinNEq) Assoc
AssocNone
    ],
    [ TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymEqEqEq (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinEq) Assoc
AssocNone,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymBangEqEq (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinNEq) Assoc
AssocNone
    ],
    [TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymAmp (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinAnd) Assoc
AssocLeft],
    [ TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymHat (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinXor) Assoc
AssocLeft,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymHatTildy (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinXNor) Assoc
AssocLeft,
      TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymTildyHat (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinXNorInv) Assoc
AssocLeft
    ],
    [TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymBar (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinOr) Assoc
AssocLeft],
    [TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymAmpAmp (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinLAnd) Assoc
AssocLeft],
    [TokenName -> (Expr -> Expr -> Expr) -> Assoc -> ParseOperator Expr
forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
SymBarBar (BinaryOperator -> Expr -> Expr -> Expr
sBinOp BinaryOperator
BinLOr) Assoc
AssocLeft]
  ]

binary :: TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary :: forall a. TokenName -> (a -> a -> a) -> Assoc -> ParseOperator a
binary TokenName
name a -> a -> a
fun = ParsecT [Token] () Identity (a -> a -> a)
-> Assoc -> Operator [Token] () Identity a
forall s u (m :: * -> *) a.
ParsecT s u m (a -> a -> a) -> Assoc -> Operator s u m a
Infix ((TokenName -> Parser TokenName
tok TokenName
name Parser TokenName -> [Char] -> Parser TokenName
forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"binary") Parser TokenName
-> ParsecT [Token] () Identity (a -> a -> a)
-> ParsecT [Token] () Identity (a -> a -> a)
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (a -> a -> a) -> ParsecT [Token] () Identity (a -> a -> a)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return a -> a -> a
fun)

prefix :: TokenName -> (a -> a) -> ParseOperator a
prefix :: forall a. TokenName -> (a -> a) -> ParseOperator a
prefix TokenName
name a -> a
fun = ParsecT [Token] () Identity (a -> a)
-> Operator [Token] () Identity a
forall s u (m :: * -> *) a.
ParsecT s u m (a -> a) -> Operator s u m a
Prefix ((TokenName -> Parser TokenName
tok TokenName
name Parser TokenName -> [Char] -> Parser TokenName
forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"prefix") Parser TokenName
-> ParsecT [Token] () Identity (a -> a)
-> ParsecT [Token] () Identity (a -> a)
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (a -> a) -> ParsecT [Token] () Identity (a -> a)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return a -> a
fun)

commaSep :: Parser a -> Parser [a]
commaSep :: forall a. Parser a -> Parser [a]
commaSep = (Parser a -> Parser TokenName -> Parser [a])
-> Parser TokenName -> Parser a -> Parser [a]
forall {t} {t} {t}. (t -> t -> t) -> t -> t -> t
flip Parser a -> Parser TokenName -> Parser [a]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy (Parser TokenName -> Parser a -> Parser [a])
-> Parser TokenName -> Parser a -> Parser [a]
forall a b. (a -> b) -> a -> b
$ TokenName -> Parser TokenName
tok TokenName
SymComma

toNE :: Parser [a] -> Parser (NonEmpty a)
toNE :: forall a. Parser [a] -> Parser (NonEmpty a)
toNE Parser [a]
p = do
  [a]
p' <- Parser [a]
p
  case [a]
p' of
    a
a : [a]
b -> NonEmpty a -> Parser (NonEmpty a)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty a -> Parser (NonEmpty a))
-> NonEmpty a -> Parser (NonEmpty a)
forall a b. (a -> b) -> a -> b
$ a
a a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
b
    [a]
_ -> [Char] -> Parser (NonEmpty a)
forall a. [Char] -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"List is empty."

commaSepNE :: Parser a -> Parser (NonEmpty a)
commaSepNE :: forall a. Parser a -> Parser (NonEmpty a)
commaSepNE = Parser [a] -> Parser (NonEmpty a)
forall a. Parser [a] -> Parser (NonEmpty a)
toNE (Parser [a] -> Parser (NonEmpty a))
-> (Parser a -> Parser [a]) -> Parser a -> Parser (NonEmpty a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser a -> Parser [a]
forall a. Parser a -> Parser [a]
commaSep

parseContAssign :: Parser ContAssign
parseContAssign :: Parser ContAssign
parseContAssign = do
  Identifier
var <- TokenName -> Parser TokenName
tok TokenName
KWAssign Parser TokenName
-> ParsecT [Token] () Identity Identifier
-> ParsecT [Token] () Identity Identifier
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [Token] () Identity Identifier
identifier
  Expr
expr <- TokenName -> Parser TokenName
tok TokenName
SymEq Parser TokenName -> Parser Expr -> Parser Expr
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Expr
parseExpr
  TokenName -> Parser ()
tok' TokenName
SymSemi
  ContAssign -> Parser ContAssign
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (ContAssign -> Parser ContAssign)
-> ContAssign -> Parser ContAssign
forall a b. (a -> b) -> a -> b
$ Identifier -> Expr -> ContAssign
ContAssign Identifier
var Expr
expr

numLit :: Parser String
numLit :: Parser [Char]
numLit = (Token -> Maybe [Char]) -> Parser [Char]
forall a. (Token -> Maybe a) -> Parser a
satisfy' Token -> Maybe [Char]
matchId
  where
    matchId :: Token -> Maybe [Char]
matchId (Token TokenName
LitNumber [Char]
s Position
_) = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
s
    matchId Token
_ = Maybe [Char]
forall a. Maybe a
Nothing

number :: Parser Decimal
number :: ParsecT [Token] () Identity Decimal
number = [Char] -> Decimal
number' ([Char] -> Decimal)
-> Parser [Char] -> ParsecT [Token] () Identity Decimal
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [Char]
numLit
  where
    number' :: String -> Decimal
    number' :: [Char] -> Decimal
number' [Char]
a
      | (Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char
'0' .. Char
'9']) [Char]
a = Integer -> Decimal
forall a. Num a => Integer -> a
fromInteger (Integer -> Decimal) -> Integer -> Decimal
forall a b. (a -> b) -> a -> b
$ [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
a
      | [Char] -> Char
forall a. HasCallStack => [a] -> a
head [Char]
a Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\'' = Integer -> Decimal
forall a. Num a => Integer -> a
fromInteger (Integer -> Decimal) -> Integer -> Decimal
forall a b. (a -> b) -> a -> b
$ [Char] -> Integer
forall {a}. (Read a, Bits a, Num a) => [Char] -> a
f [Char]
a
      | [Char]
"'" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isInfixOf` [Char]
a = Int -> Integer -> Decimal
Decimal ([Char] -> Int
forall a. Read a => [Char] -> a
read [Char]
w) ([Char] -> Integer
forall {a}. (Read a, Bits a, Num a) => [Char] -> a
f [Char]
b)
      | Bool
otherwise = [Char] -> Decimal
forall a. HasCallStack => [Char] -> a
error ([Char] -> Decimal) -> [Char] -> Decimal
forall a b. (a -> b) -> a -> b
$ [Char]
"Invalid number format: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
a
      where
        w :: [Char]
w = (Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\'') [Char]
a
        b :: [Char]
b = (Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\'') [Char]
a
        f :: [Char] -> a
f [Char]
a'
          | [Char]
"'d" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` [Char]
a' = [Char] -> a
forall a. Read a => [Char] -> a
read ([Char] -> a) -> [Char] -> a
forall a b. (a -> b) -> a -> b
$ Int -> [Char] -> [Char]
forall a. Int -> [a] -> [a]
drop Int
2 [Char]
a'
          | [Char]
"'h" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` [Char]
a' = [Char] -> a
forall a. Read a => [Char] -> a
read ([Char] -> a) -> [Char] -> a
forall a b. (a -> b) -> a -> b
$ [Char]
"0x" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char] -> [Char]
forall a. Int -> [a] -> [a]
drop Int
2 [Char]
a'
          | [Char]
"'b" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` [Char]
a' =
            (a -> Char -> a) -> a -> [Char] -> a
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl
              (\a
n Char
b' -> a -> Int -> a
forall a. Bits a => a -> Int -> a
shiftL a
n Int
1 a -> a -> a
forall a. Bits a => a -> a -> a
.|. (if Char
b' Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'1' then a
1 else a
0))
              a
0
              (Int -> [Char] -> [Char]
forall a. Int -> [a] -> [a]
drop Int
2 [Char]
a')
          | Bool
otherwise = [Char] -> a
forall a. HasCallStack => [Char] -> a
error ([Char] -> a) -> [Char] -> a
forall a b. (a -> b) -> a -> b
$ [Char]
"Invalid number format: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
a'

-- toInteger' :: Decimal -> Integer
-- toInteger' (Decimal _ n) = n

toInt' :: Decimal -> Int
toInt' :: Decimal -> Int
toInt' (Decimal Int
_ Integer
n) = Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
n

-- | Parse a range and return the total size. As it is inclusive, 1 has to be
-- added to the difference.
parseRange :: Parser Range
parseRange :: Parser Range
parseRange = do
  ConstExpr
rangeH <- TokenName -> Parser TokenName
tok TokenName
SymBrackL Parser TokenName -> Parser ConstExpr -> Parser ConstExpr
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ConstExpr
parseConstExpr
  ConstExpr
rangeL <- TokenName -> Parser TokenName
tok TokenName
SymColon Parser TokenName -> Parser ConstExpr -> Parser ConstExpr
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ConstExpr
parseConstExpr
  TokenName -> Parser ()
tok' TokenName
SymBrackR
  Range -> Parser Range
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Range -> Parser Range) -> Range -> Parser Range
forall a b. (a -> b) -> a -> b
$ ConstExpr -> ConstExpr -> Range
Range ConstExpr
rangeH ConstExpr
rangeL

strId :: Parser String
strId :: Parser [Char]
strId = (Token -> Maybe [Char]) -> Parser [Char]
forall a. (Token -> Maybe a) -> Parser a
satisfy' Token -> Maybe [Char]
matchId
  where
    matchId :: Token -> Maybe [Char]
matchId (Token TokenName
IdSimple [Char]
s Position
_) = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
s
    matchId (Token TokenName
IdEscaped [Char]
s Position
_) = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
s
    matchId Token
_ = Maybe [Char]
forall a. Maybe a
Nothing

identifier :: Parser Identifier
identifier :: ParsecT [Token] () Identity Identifier
identifier = Text -> Identifier
Identifier (Text -> Identifier) -> ([Char] -> Text) -> [Char] -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Text
T.pack ([Char] -> Identifier)
-> Parser [Char] -> ParsecT [Token] () Identity Identifier
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [Char]
strId

parseNetDecl :: Maybe PortDir -> Parser (ModItem ann)
parseNetDecl :: forall ann. Maybe PortDir -> Parser (ModItem ann)
parseNetDecl Maybe PortDir
pd = do
  PortType
t <- PortType
-> ParsecT [Token] () Identity PortType
-> ParsecT [Token] () Identity PortType
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option PortType
Wire ParsecT [Token] () Identity PortType
type_
  Bool
sign <- Bool
-> ParsecT [Token] () Identity Bool
-> ParsecT [Token] () Identity Bool
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Bool
False (TokenName -> Parser TokenName
tok TokenName
KWSigned Parser TokenName -> Bool -> ParsecT [Token] () Identity Bool
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool
True)
  Range
range <- Range -> Parser Range -> Parser Range
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Range
1 Parser Range
parseRange
  Identifier
name <- ParsecT [Token] () Identity Identifier
identifier
  Maybe ConstExpr
i <- Maybe ConstExpr
-> ParsecT [Token] () Identity (Maybe ConstExpr)
-> ParsecT [Token] () Identity (Maybe ConstExpr)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe ConstExpr
forall a. Maybe a
Nothing ((ConstExpr -> Maybe ConstExpr)
-> Parser ConstExpr
-> ParsecT [Token] () Identity (Maybe ConstExpr)
forall a b.
(a -> b)
-> ParsecT [Token] () Identity a -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ConstExpr -> Maybe ConstExpr
forall a. a -> Maybe a
Just (TokenName -> Parser ()
tok' TokenName
SymEq Parser () -> Parser ConstExpr -> Parser ConstExpr
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ConstExpr
parseConstExpr))
  TokenName -> Parser ()
tok' TokenName
SymSemi
  ModItem ann -> Parser (ModItem ann)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (ModItem ann -> Parser (ModItem ann))
-> ModItem ann -> Parser (ModItem ann)
forall a b. (a -> b) -> a -> b
$ Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem ann
forall a. Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
Decl Maybe PortDir
pd (PortType -> Bool -> Range -> Identifier -> Port
Port PortType
t Bool
sign Range
range Identifier
name) Maybe ConstExpr
i
  where
    type_ :: ParsecT [Token] () Identity PortType
type_ = TokenName -> Parser TokenName
tok TokenName
KWWire Parser TokenName
-> PortType -> ParsecT [Token] () Identity PortType
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> PortType
Wire ParsecT [Token] () Identity PortType
-> ParsecT [Token] () Identity PortType
-> ParsecT [Token] () Identity PortType
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TokenName -> Parser TokenName
tok TokenName
KWReg Parser TokenName
-> PortType -> ParsecT [Token] () Identity PortType
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> PortType
Reg

parsePortDir :: Parser PortDir
parsePortDir :: Parser PortDir
parsePortDir =
  TokenName -> Parser TokenName
tok TokenName
KWOutput
    Parser TokenName -> PortDir -> Parser PortDir
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> PortDir
PortOut
    Parser PortDir -> Parser PortDir -> Parser PortDir
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TokenName -> Parser TokenName
tok TokenName
KWInput
      Parser TokenName -> PortDir -> Parser PortDir
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> PortDir
PortIn
    Parser PortDir -> Parser PortDir -> Parser PortDir
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TokenName -> Parser TokenName
tok TokenName
KWInout
      Parser TokenName -> PortDir -> Parser PortDir
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> PortDir
PortInOut

parseDecl :: Parser (ModItem ann)
parseDecl :: forall ann. Parser (ModItem ann)
parseDecl = (PortDir -> Maybe PortDir
forall a. a -> Maybe a
Just (PortDir -> Maybe PortDir)
-> Parser PortDir -> ParsecT [Token] () Identity (Maybe PortDir)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser PortDir
parsePortDir ParsecT [Token] () Identity (Maybe PortDir)
-> (Maybe PortDir -> ParsecT [Token] () Identity (ModItem ann))
-> ParsecT [Token] () Identity (ModItem ann)
forall a b.
ParsecT [Token] () Identity a
-> (a -> ParsecT [Token] () Identity b)
-> ParsecT [Token] () Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Maybe PortDir -> ParsecT [Token] () Identity (ModItem ann)
forall ann. Maybe PortDir -> Parser (ModItem ann)
parseNetDecl) ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Maybe PortDir -> ParsecT [Token] () Identity (ModItem ann)
forall ann. Maybe PortDir -> Parser (ModItem ann)
parseNetDecl Maybe PortDir
forall a. Maybe a
Nothing

parseConditional :: Parser (Statement ann)
parseConditional :: forall ann. Parser (Statement ann)
parseConditional = do
  Expr
expr <- TokenName -> Parser ()
tok' TokenName
KWIf Parser () -> Parser Expr -> Parser Expr
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
parens Parser Expr
parseExpr
  Maybe (Statement ann)
true <- Parser (Maybe (Statement ann))
forall ann. Parser (Maybe (Statement ann))
maybeEmptyStatement
  Maybe (Statement ann)
false <- Maybe (Statement ann)
-> Parser (Maybe (Statement ann)) -> Parser (Maybe (Statement ann))
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe (Statement ann)
forall a. Maybe a
Nothing (TokenName -> Parser ()
tok' TokenName
KWElse Parser ()
-> Parser (Maybe (Statement ann)) -> Parser (Maybe (Statement ann))
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Maybe (Statement ann))
forall ann. Parser (Maybe (Statement ann))
maybeEmptyStatement)
  Statement ann -> Parser (Statement ann)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement ann -> Parser (Statement ann))
-> Statement ann -> Parser (Statement ann)
forall a b. (a -> b) -> a -> b
$ Expr
-> Maybe (Statement ann) -> Maybe (Statement ann) -> Statement ann
forall a.
Expr -> Maybe (Statement a) -> Maybe (Statement a) -> Statement a
CondStmnt Expr
expr Maybe (Statement ann)
true Maybe (Statement ann)
false

parseLVal :: Parser LVal
parseLVal :: Parser LVal
parseLVal = ([Expr] -> LVal) -> Parser [Expr] -> Parser LVal
forall a b.
(a -> b)
-> ParsecT [Token] () Identity a -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Expr] -> LVal
RegConcat (Parser [Expr] -> Parser [Expr]
forall a. Parser a -> Parser a
braces (Parser [Expr] -> Parser [Expr]) -> Parser [Expr] -> Parser [Expr]
forall a b. (a -> b) -> a -> b
$ Parser Expr -> Parser [Expr]
forall a. Parser a -> Parser [a]
commaSep Parser Expr
parseExpr) Parser LVal -> Parser LVal -> Parser LVal
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser LVal
ident
  where
    ident :: Parser LVal
ident = do
      Identifier
i <- ParsecT [Token] () Identity Identifier
identifier
      (Parser LVal -> Parser LVal
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Identifier -> Parser LVal
ex Identifier
i) Parser LVal -> Parser LVal -> Parser LVal
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser LVal -> Parser LVal
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Identifier -> Parser LVal
sz Identifier
i) Parser LVal -> Parser LVal -> Parser LVal
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> LVal -> Parser LVal
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Identifier -> LVal
RegId Identifier
i))
    ex :: Identifier -> Parser LVal
ex Identifier
i = do
      Expr
e <- TokenName -> Parser ()
tok' TokenName
SymBrackL Parser () -> Parser Expr -> Parser Expr
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Expr
parseExpr
      TokenName -> Parser ()
tok' TokenName
SymBrackR
      LVal -> Parser LVal
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (LVal -> Parser LVal) -> LVal -> Parser LVal
forall a b. (a -> b) -> a -> b
$ Identifier -> Expr -> LVal
RegExpr Identifier
i Expr
e
    sz :: Identifier -> Parser LVal
sz Identifier
i = Identifier -> Range -> LVal
RegSize Identifier
i (Range -> LVal) -> Parser Range -> Parser LVal
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Range
parseRange

parseDelay :: Parser Delay
parseDelay :: Parser Delay
parseDelay = Int -> Delay
Delay (Int -> Delay) -> (Decimal -> Int) -> Decimal -> Delay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Int
toInt' (Decimal -> Delay)
-> ParsecT [Token] () Identity Decimal -> Parser Delay
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TokenName -> Parser ()
tok' TokenName
SymPound Parser ()
-> ParsecT [Token] () Identity Decimal
-> ParsecT [Token] () Identity Decimal
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [Token] () Identity Decimal
number)

parseAssign :: TokenName -> Parser Assign
parseAssign :: TokenName -> Parser Assign
parseAssign TokenName
t = do
  LVal
lval <- Parser LVal
parseLVal
  TokenName -> Parser ()
tok' TokenName
t
  Maybe Delay
delay <- Maybe Delay
-> ParsecT [Token] () Identity (Maybe Delay)
-> ParsecT [Token] () Identity (Maybe Delay)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe Delay
forall a. Maybe a
Nothing ((Delay -> Maybe Delay)
-> Parser Delay -> ParsecT [Token] () Identity (Maybe Delay)
forall a b.
(a -> b)
-> ParsecT [Token] () Identity a -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Delay -> Maybe Delay
forall a. a -> Maybe a
Just Parser Delay
parseDelay)
  Expr
expr <- Parser Expr
parseExpr
  Assign -> Parser Assign
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Assign -> Parser Assign) -> Assign -> Parser Assign
forall a b. (a -> b) -> a -> b
$ LVal -> Maybe Delay -> Expr -> Assign
Assign LVal
lval Maybe Delay
delay Expr
expr

parseLoop :: Parser (Statement ann)
parseLoop :: forall ann. Parser (Statement ann)
parseLoop = do
  Assign
a <- TokenName -> Parser ()
tok' TokenName
KWFor Parser () -> Parser () -> Parser ()
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TokenName -> Parser ()
tok' TokenName
SymParenL Parser () -> Parser Assign -> Parser Assign
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TokenName -> Parser Assign
parseAssign TokenName
SymEq
  Expr
expr <- TokenName -> Parser ()
tok' TokenName
SymSemi Parser () -> Parser Expr -> Parser Expr
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Expr
parseExpr
  Assign
incr <- TokenName -> Parser ()
tok' TokenName
SymSemi Parser () -> Parser Assign -> Parser Assign
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TokenName -> Parser Assign
parseAssign TokenName
SymEq
  TokenName -> Parser ()
tok' TokenName
SymParenR
  Statement ann
statement <- Parser (Statement ann)
forall ann. Parser (Statement ann)
parseStatement
  Statement ann -> Parser (Statement ann)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement ann -> Parser (Statement ann))
-> Statement ann -> Parser (Statement ann)
forall a b. (a -> b) -> a -> b
$ Assign -> Expr -> Assign -> Statement ann -> Statement ann
forall a. Assign -> Expr -> Assign -> Statement a -> Statement a
ForLoop Assign
a Expr
expr Assign
incr Statement ann
statement

parseDefaultPair :: Parser (Statement a)
parseDefaultPair :: forall ann. Parser (Statement ann)
parseDefaultPair = TokenName -> Parser ()
tok' TokenName
KWDefault Parser () -> Parser () -> Parser ()
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TokenName -> Parser ()
tok' TokenName
SymColon Parser ()
-> ParsecT [Token] () Identity (Statement a)
-> ParsecT [Token] () Identity (Statement a)
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [Token] () Identity (Statement a)
forall ann. Parser (Statement ann)
parseStatement

parseCasePair :: Parser (CasePair ann)
parseCasePair :: forall ann. Parser (CasePair ann)
parseCasePair = do
  Expr
expr <- Parser Expr
parseExpr Parser Expr -> Parser () -> Parser Expr
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* TokenName -> Parser ()
tok' TokenName
SymColon
  Expr -> Statement ann -> CasePair ann
forall a. Expr -> Statement a -> CasePair a
CasePair Expr
expr (Statement ann -> CasePair ann)
-> ParsecT [Token] () Identity (Statement ann)
-> Parser (CasePair ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Token] () Identity (Statement ann)
forall ann. Parser (Statement ann)
parseStatement

parseCase :: Parser (Statement ann)
parseCase :: forall ann. Parser (Statement ann)
parseCase = do
  Expr
expr <- TokenName -> Parser ()
tok' TokenName
KWCase Parser () -> Parser Expr -> Parser Expr
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Expr
parseExpr
  [CasePair ann]
cp <- ParsecT [Token] () Identity (CasePair ann)
-> Parser () -> ParsecT [Token] () Identity [CasePair ann]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
manyTill ParsecT [Token] () Identity (CasePair ann)
forall ann. Parser (CasePair ann)
parseCasePair (Parser () -> Parser ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead ((Parser (Statement Any)
forall ann. Parser (Statement ann)
parseDefaultPair Parser (Statement Any) -> () -> Parser ()
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ()) Parser () -> Parser () -> Parser ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TokenName -> Parser ()
tok' TokenName
KWEndcase))
  Maybe (Statement ann)
def <- Maybe (Statement ann)
-> ParsecT [Token] () Identity (Maybe (Statement ann))
-> ParsecT [Token] () Identity (Maybe (Statement ann))
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe (Statement ann)
forall a. Maybe a
Nothing (ParsecT [Token] () Identity (Maybe (Statement ann))
 -> ParsecT [Token] () Identity (Maybe (Statement ann)))
-> ParsecT [Token] () Identity (Maybe (Statement ann))
-> ParsecT [Token] () Identity (Maybe (Statement ann))
forall a b. (a -> b) -> a -> b
$ Statement ann -> Maybe (Statement ann)
forall a. a -> Maybe a
Just (Statement ann -> Maybe (Statement ann))
-> Parser (Statement ann)
-> ParsecT [Token] () Identity (Maybe (Statement ann))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Statement ann)
forall ann. Parser (Statement ann)
parseDefaultPair
  TokenName -> Parser ()
tok' TokenName
KWEndcase
  Statement ann -> Parser (Statement ann)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (CaseType
-> Expr -> [CasePair ann] -> Maybe (Statement ann) -> Statement ann
forall a.
CaseType
-> Expr -> [CasePair a] -> Maybe (Statement a) -> Statement a
StmntCase CaseType
CaseStandard Expr
expr [CasePair ann]
cp Maybe (Statement ann)
def)

eventList :: TokenName -> Parser [Event]
eventList :: TokenName -> Parser [Event]
eventList TokenName
t = do
  [Event]
l <- ParsecT [Token] () Identity Event
-> Parser TokenName -> Parser [Event]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT [Token] () Identity Event
parseEvent' (TokenName -> Parser TokenName
tok TokenName
t)
  if [Event] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Event]
l then [Char] -> Parser [Event]
forall a. [Char] -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"Could not parse list" else [Event] -> Parser [Event]
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return [Event]
l

parseEvent :: Parser Event
parseEvent :: ParsecT [Token] () Identity Event
parseEvent =
  (TokenName -> Parser ()
tok' TokenName
SymAtAster Parser () -> Event -> ParsecT [Token] () Identity Event
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Event
EAll)
    ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TokenName -> Parser ()
tok' TokenName
SymAt Parser () -> Parser () -> Parser ()
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TokenName -> Parser ()
tok' TokenName
SymParenLAsterParenR Parser () -> Event -> ParsecT [Token] () Identity Event
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Event
EAll)
    ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try
      ( TokenName -> Parser ()
tok' TokenName
SymAt
          Parser () -> Parser () -> Parser ()
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser () -> Parser ()
forall a. Parser a -> Parser a
parens (TokenName -> Parser ()
tok' TokenName
SymAster)
          Parser () -> Event -> ParsecT [Token] () Identity Event
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Event
EAll
      )
    ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TokenName -> Parser ()
tok' TokenName
SymAt Parser ()
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall a. Parser a -> Parser a
parens ParsecT [Token] () Identity Event
parseEvent')
    ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TokenName -> Parser ()
tok' TokenName
SymAt Parser ()
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall a. Parser a -> Parser a
parens ((Event -> Event -> Event) -> [Event] -> Event
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 Event -> Event -> Event
EOr ([Event] -> Event)
-> Parser [Event] -> ParsecT [Token] () Identity Event
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TokenName -> Parser [Event]
eventList TokenName
KWOr))
    ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TokenName -> Parser ()
tok' TokenName
SymAt Parser ()
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall a. Parser a -> Parser a
parens ((Event -> Event -> Event) -> [Event] -> Event
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 Event -> Event -> Event
EComb ([Event] -> Event)
-> Parser [Event] -> ParsecT [Token] () Identity Event
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TokenName -> Parser [Event]
eventList TokenName
SymComma))

parseEvent' :: Parser Event
parseEvent' :: ParsecT [Token] () Identity Event
parseEvent' =
  ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TokenName -> Parser ()
tok' TokenName
KWPosedge Parser ()
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Identifier -> Event)
-> ParsecT [Token] () Identity Identifier
-> ParsecT [Token] () Identity Event
forall a b.
(a -> b)
-> ParsecT [Token] () Identity a -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identifier -> Event
EPosEdge ParsecT [Token] () Identity Identifier
identifier)
    ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TokenName -> Parser ()
tok' TokenName
KWNegedge Parser ()
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Identifier -> Event)
-> ParsecT [Token] () Identity Identifier
-> ParsecT [Token] () Identity Event
forall a b.
(a -> b)
-> ParsecT [Token] () Identity a -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identifier -> Event
ENegEdge ParsecT [Token] () Identity Identifier
identifier)
    ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ((Identifier -> Event)
-> ParsecT [Token] () Identity Identifier
-> ParsecT [Token] () Identity Event
forall a b.
(a -> b)
-> ParsecT [Token] () Identity a -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identifier -> Event
EId ParsecT [Token] () Identity Identifier
identifier)
    ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity Event
-> ParsecT [Token] () Identity Event
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ((Expr -> Event) -> Parser Expr -> ParsecT [Token] () Identity Event
forall a b.
(a -> b)
-> ParsecT [Token] () Identity a -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr -> Event
EExpr Parser Expr
parseExpr)

parseEventCtrl :: Parser (Statement ann)
parseEventCtrl :: forall ann. Parser (Statement ann)
parseEventCtrl = do
  Event
event <- ParsecT [Token] () Identity Event
parseEvent
  Maybe (Statement ann)
statement <- Maybe (Statement ann)
-> ParsecT [Token] () Identity (Maybe (Statement ann))
-> ParsecT [Token] () Identity (Maybe (Statement ann))
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe (Statement ann)
forall a. Maybe a
Nothing ParsecT [Token] () Identity (Maybe (Statement ann))
forall ann. Parser (Maybe (Statement ann))
maybeEmptyStatement
  Statement ann -> Parser (Statement ann)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement ann -> Parser (Statement ann))
-> Statement ann -> Parser (Statement ann)
forall a b. (a -> b) -> a -> b
$ Event -> Maybe (Statement ann) -> Statement ann
forall a. Event -> Maybe (Statement a) -> Statement a
EventCtrl Event
event Maybe (Statement ann)
statement

parseDelayCtrl :: Parser (Statement ann)
parseDelayCtrl :: forall ann. Parser (Statement ann)
parseDelayCtrl = do
  Delay
delay <- Parser Delay
parseDelay
  Maybe (Statement ann)
statement <- Maybe (Statement ann)
-> ParsecT [Token] () Identity (Maybe (Statement ann))
-> ParsecT [Token] () Identity (Maybe (Statement ann))
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe (Statement ann)
forall a. Maybe a
Nothing ParsecT [Token] () Identity (Maybe (Statement ann))
forall ann. Parser (Maybe (Statement ann))
maybeEmptyStatement
  Statement ann -> Parser (Statement ann)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement ann -> Parser (Statement ann))
-> Statement ann -> Parser (Statement ann)
forall a b. (a -> b) -> a -> b
$ Delay -> Maybe (Statement ann) -> Statement ann
forall a. Delay -> Maybe (Statement a) -> Statement a
TimeCtrl Delay
delay Maybe (Statement ann)
statement

parseBlocking :: Parser (Statement ann)
parseBlocking :: forall ann. Parser (Statement ann)
parseBlocking = do
  Assign
a <- TokenName -> Parser Assign
parseAssign TokenName
SymEq
  TokenName -> Parser ()
tok' TokenName
SymSemi
  Statement ann -> Parser (Statement ann)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement ann -> Parser (Statement ann))
-> Statement ann -> Parser (Statement ann)
forall a b. (a -> b) -> a -> b
$ Assign -> Statement ann
forall a. Assign -> Statement a
BlockAssign Assign
a

parseNonBlocking :: Parser (Statement ann)
parseNonBlocking :: forall ann. Parser (Statement ann)
parseNonBlocking = do
  Assign
a <- TokenName -> Parser Assign
parseAssign TokenName
SymLtEq
  TokenName -> Parser ()
tok' TokenName
SymSemi
  Statement ann -> Parser (Statement ann)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement ann -> Parser (Statement ann))
-> Statement ann -> Parser (Statement ann)
forall a b. (a -> b) -> a -> b
$ Assign -> Statement ann
forall a. Assign -> Statement a
NonBlockAssign Assign
a

parseSeq :: Parser (Statement ann)
parseSeq :: forall ann. Parser (Statement ann)
parseSeq = do
  [Statement ann]
seq' <- TokenName -> Parser ()
tok' TokenName
KWBegin Parser ()
-> ParsecT [Token] () Identity [Statement ann]
-> ParsecT [Token] () Identity [Statement ann]
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Statement ann)
-> ParsecT [Token] () Identity [Statement ann]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser (Statement ann)
forall ann. Parser (Statement ann)
parseStatement
  TokenName -> Parser ()
tok' TokenName
KWEnd
  Statement ann -> Parser (Statement ann)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement ann -> Parser (Statement ann))
-> Statement ann -> Parser (Statement ann)
forall a b. (a -> b) -> a -> b
$ [Statement ann] -> Statement ann
forall a. [Statement a] -> Statement a
SeqBlock [Statement ann]
seq'

parseStatement :: Parser (Statement ann)
parseStatement :: forall ann. Parser (Statement ann)
parseStatement =
  Parser (Statement ann)
forall ann. Parser (Statement ann)
parseSeq
    Parser (Statement ann)
-> Parser (Statement ann) -> Parser (Statement ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (Statement ann)
forall ann. Parser (Statement ann)
parseConditional
    Parser (Statement ann)
-> Parser (Statement ann) -> Parser (Statement ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (Statement ann)
forall ann. Parser (Statement ann)
parseLoop
    Parser (Statement ann)
-> Parser (Statement ann) -> Parser (Statement ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (Statement ann)
forall ann. Parser (Statement ann)
parseCase
    Parser (Statement ann)
-> Parser (Statement ann) -> Parser (Statement ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (Statement ann)
forall ann. Parser (Statement ann)
parseEventCtrl
    Parser (Statement ann)
-> Parser (Statement ann) -> Parser (Statement ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (Statement ann)
forall ann. Parser (Statement ann)
parseDelayCtrl
    Parser (Statement ann)
-> Parser (Statement ann) -> Parser (Statement ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (Statement ann) -> Parser (Statement ann)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser (Statement ann)
forall ann. Parser (Statement ann)
parseBlocking
    Parser (Statement ann)
-> Parser (Statement ann) -> Parser (Statement ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser (Statement ann)
forall ann. Parser (Statement ann)
parseNonBlocking

maybeEmptyStatement :: Parser (Maybe (Statement ann))
maybeEmptyStatement :: forall ann. Parser (Maybe (Statement ann))
maybeEmptyStatement =
  (TokenName -> Parser ()
tok' TokenName
SymSemi Parser ()
-> ParsecT [Token] () Identity (Maybe (Statement ann))
-> ParsecT [Token] () Identity (Maybe (Statement ann))
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Maybe (Statement ann)
-> ParsecT [Token] () Identity (Maybe (Statement ann))
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Statement ann)
forall a. Maybe a
Nothing) ParsecT [Token] () Identity (Maybe (Statement ann))
-> ParsecT [Token] () Identity (Maybe (Statement ann))
-> ParsecT [Token] () Identity (Maybe (Statement ann))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Statement ann -> Maybe (Statement ann)
forall a. a -> Maybe a
Just (Statement ann -> Maybe (Statement ann))
-> ParsecT [Token] () Identity (Statement ann)
-> ParsecT [Token] () Identity (Maybe (Statement ann))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Token] () Identity (Statement ann)
forall ann. Parser (Statement ann)
parseStatement)

parseAlways :: Parser (ModItem ann)
parseAlways :: forall ann. Parser (ModItem ann)
parseAlways = TokenName -> Parser ()
tok' TokenName
KWAlways Parser ()
-> ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Statement ann -> ModItem ann
forall a. Statement a -> ModItem a
Always (Statement ann -> ModItem ann)
-> ParsecT [Token] () Identity (Statement ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Token] () Identity (Statement ann)
forall ann. Parser (Statement ann)
parseStatement)

parseInitial :: Parser (ModItem ann)
parseInitial :: forall ann. Parser (ModItem ann)
parseInitial = TokenName -> Parser ()
tok' TokenName
KWInitial Parser ()
-> ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Statement ann -> ModItem ann
forall a. Statement a -> ModItem a
Initial (Statement ann -> ModItem ann)
-> ParsecT [Token] () Identity (Statement ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Token] () Identity (Statement ann)
forall ann. Parser (Statement ann)
parseStatement)

namedModConn :: Parser ModConn
namedModConn :: Parser ModConn
namedModConn = do
  Identifier
target <- TokenName -> Parser ()
tok' TokenName
SymDot Parser ()
-> ParsecT [Token] () Identity Identifier
-> ParsecT [Token] () Identity Identifier
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [Token] () Identity Identifier
identifier
  Expr
expr <- Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
parens Parser Expr
parseExpr
  ModConn -> Parser ModConn
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (ModConn -> Parser ModConn) -> ModConn -> Parser ModConn
forall a b. (a -> b) -> a -> b
$ Identifier -> Expr -> ModConn
ModConnNamed Identifier
target Expr
expr

parseModConn :: Parser ModConn
parseModConn :: Parser ModConn
parseModConn = Parser ModConn -> Parser ModConn
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ((Expr -> ModConn) -> Parser Expr -> Parser ModConn
forall a b.
(a -> b)
-> ParsecT [Token] () Identity a -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr -> ModConn
ModConn Parser Expr
parseExpr) Parser ModConn -> Parser ModConn -> Parser ModConn
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser ModConn
namedModConn

parseModInst :: Parser (ModItem ann)
parseModInst :: forall ann. Parser (ModItem ann)
parseModInst = do
  Identifier
m <- ParsecT [Token] () Identity Identifier
identifier
  [ModConn]
params <- [ModConn]
-> ParsecT [Token] () Identity [ModConn]
-> ParsecT [Token] () Identity [ModConn]
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (ParsecT [Token] () Identity [ModConn]
 -> ParsecT [Token] () Identity [ModConn])
-> ParsecT [Token] () Identity [ModConn]
-> ParsecT [Token] () Identity [ModConn]
forall a b. (a -> b) -> a -> b
$ TokenName -> Parser ()
tok' TokenName
SymPound Parser ()
-> ParsecT [Token] () Identity [ModConn]
-> ParsecT [Token] () Identity [ModConn]
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [Token] () Identity [ModConn]
-> ParsecT [Token] () Identity [ModConn]
forall a. Parser a -> Parser a
parens (Parser ModConn -> ParsecT [Token] () Identity [ModConn]
forall a. Parser a -> Parser [a]
commaSep Parser ModConn
parseModConn)
  Identifier
name <- ParsecT [Token] () Identity Identifier
identifier
  [ModConn]
modconns <- ParsecT [Token] () Identity [ModConn]
-> ParsecT [Token] () Identity [ModConn]
forall a. Parser a -> Parser a
parens (Parser ModConn -> ParsecT [Token] () Identity [ModConn]
forall a. Parser a -> Parser [a]
commaSep Parser ModConn
parseModConn)
  TokenName -> Parser ()
tok' TokenName
SymSemi
  ModItem ann -> Parser (ModItem ann)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (ModItem ann -> Parser (ModItem ann))
-> ModItem ann -> Parser (ModItem ann)
forall a b. (a -> b) -> a -> b
$ Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem ann
forall a.
Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem a
ModInst Identifier
m [ModConn]
params Identifier
name [ModConn]
modconns

parseParam :: Parser Parameter
parseParam :: Parser Parameter
parseParam = do
  Identifier
i <- TokenName -> Parser ()
tok' TokenName
KWParameter Parser ()
-> ParsecT [Token] () Identity Identifier
-> ParsecT [Token] () Identity Identifier
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [Token] () Identity Identifier
identifier
  ConstExpr
expr <- TokenName -> Parser ()
tok' TokenName
SymEq Parser () -> Parser ConstExpr -> Parser ConstExpr
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ConstExpr
parseConstExpr
  Parameter -> Parser Parameter
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Parameter -> Parser Parameter) -> Parameter -> Parser Parameter
forall a b. (a -> b) -> a -> b
$ Identifier -> ConstExpr -> Parameter
Parameter Identifier
i ConstExpr
expr

parseParam' :: Parser Parameter
parseParam' :: Parser Parameter
parseParam' = do
  Identifier
i <- ParsecT [Token] () Identity Identifier
identifier
  ConstExpr
expr <- TokenName -> Parser ()
tok' TokenName
SymEq Parser () -> Parser ConstExpr -> Parser ConstExpr
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ConstExpr
parseConstExpr
  Parameter -> Parser Parameter
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Parameter -> Parser Parameter) -> Parameter -> Parser Parameter
forall a b. (a -> b) -> a -> b
$ Identifier -> ConstExpr -> Parameter
Parameter Identifier
i ConstExpr
expr

parseParams :: Parser [Parameter]
parseParams :: Parser [Parameter]
parseParams = TokenName -> Parser ()
tok' TokenName
SymPound Parser () -> Parser [Parameter] -> Parser [Parameter]
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser [Parameter] -> Parser [Parameter]
forall a. Parser a -> Parser a
parens (Parser Parameter -> Parser [Parameter]
forall a. Parser a -> Parser [a]
commaSep Parser Parameter
parseParam)

parseParamDecl :: Parser (ModItem ann)
parseParamDecl :: forall ann. Parser (ModItem ann)
parseParamDecl =
  NonEmpty Parameter -> ModItem ann
forall a. NonEmpty Parameter -> ModItem a
ParamDecl (NonEmpty Parameter -> ModItem ann)
-> ParsecT [Token] () Identity (NonEmpty Parameter)
-> ParsecT [Token] () Identity (ModItem ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TokenName -> Parser ()
tok' TokenName
KWParameter Parser ()
-> ParsecT [Token] () Identity (NonEmpty Parameter)
-> ParsecT [Token] () Identity (NonEmpty Parameter)
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Parameter
-> ParsecT [Token] () Identity (NonEmpty Parameter)
forall a. Parser a -> Parser (NonEmpty a)
commaSepNE Parser Parameter
parseParam' ParsecT [Token] () Identity (NonEmpty Parameter)
-> Parser () -> ParsecT [Token] () Identity (NonEmpty Parameter)
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* TokenName -> Parser ()
tok' TokenName
SymSemi)

parseModItem :: Parser (ModItem ann)
parseModItem :: forall ann. Parser (ModItem ann)
parseModItem =
  ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ContAssign -> ModItem ann
forall a. ContAssign -> ModItem a
ModCA (ContAssign -> ModItem ann)
-> Parser ContAssign -> ParsecT [Token] () Identity (ModItem ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ContAssign
parseContAssign)
    ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT [Token] () Identity (ModItem ann)
forall ann. Parser (ModItem ann)
parseDecl
    ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity (ModItem ann)
forall ann. Parser (ModItem ann)
parseAlways
    ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity (ModItem ann)
forall ann. Parser (ModItem ann)
parseInitial
    ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity (ModItem ann)
forall ann. Parser (ModItem ann)
parseModInst
    ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity (ModItem ann)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Token] () Identity (ModItem ann)
forall ann. Parser (ModItem ann)
parseParamDecl

parseModList :: Parser [Identifier]
parseModList :: Parser [Identifier]
parseModList = Parser [Identifier]
list Parser [Identifier] -> Parser [Identifier] -> Parser [Identifier]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> [Identifier] -> Parser [Identifier]
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return [] where list :: Parser [Identifier]
list = Parser [Identifier] -> Parser [Identifier]
forall a. Parser a -> Parser a
parens (Parser [Identifier] -> Parser [Identifier])
-> Parser [Identifier] -> Parser [Identifier]
forall a b. (a -> b) -> a -> b
$ ParsecT [Token] () Identity Identifier -> Parser [Identifier]
forall a. Parser a -> Parser [a]
commaSep ParsecT [Token] () Identity Identifier
identifier

filterDecl :: PortDir -> (ModItem ann) -> Bool
filterDecl :: forall ann. PortDir -> ModItem ann -> Bool
filterDecl PortDir
p (Decl (Just PortDir
p') Port
_ Maybe ConstExpr
_) = PortDir
p PortDir -> PortDir -> Bool
forall a. Eq a => a -> a -> Bool
== PortDir
p'
filterDecl PortDir
_ ModItem ann
_ = Bool
False

modPorts :: PortDir -> [ModItem ann] -> [Port]
modPorts :: forall ann. PortDir -> [ModItem ann] -> [Port]
modPorts PortDir
p [ModItem ann]
mis = (ModItem ann -> Bool) -> [ModItem ann] -> [ModItem ann]
forall a. (a -> Bool) -> [a] -> [a]
filter (PortDir -> ModItem ann -> Bool
forall ann. PortDir -> ModItem ann -> Bool
filterDecl PortDir
p) [ModItem ann]
mis [ModItem ann] -> Getting (Endo [Port]) [ModItem ann] Port -> [Port]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. (ModItem ann -> Const (Endo [Port]) (ModItem ann))
-> [ModItem ann] -> Const (Endo [Port]) [ModItem ann]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((ModItem ann -> Const (Endo [Port]) (ModItem ann))
 -> [ModItem ann] -> Const (Endo [Port]) [ModItem ann])
-> ((Port -> Const (Endo [Port]) Port)
    -> ModItem ann -> Const (Endo [Port]) (ModItem ann))
-> Getting (Endo [Port]) [ModItem ann] Port
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Port -> Const (Endo [Port]) Port)
-> ModItem ann -> Const (Endo [Port]) (ModItem ann)
forall a (f :: * -> *).
Applicative f =>
(Port -> f Port) -> ModItem a -> f (ModItem a)
declPort

parseModDecl :: Parser (ModDecl ann)
parseModDecl :: forall ann. Parser (ModDecl ann)
parseModDecl = do
  Identifier
name <- TokenName -> Parser TokenName
tok TokenName
KWModule Parser TokenName
-> ParsecT [Token] () Identity Identifier
-> ParsecT [Token] () Identity Identifier
forall a b.
ParsecT [Token] () Identity a
-> ParsecT [Token] () Identity b -> ParsecT [Token] () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [Token] () Identity Identifier
identifier
  [Parameter]
paramList <- [Parameter] -> Parser [Parameter] -> Parser [Parameter]
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (Parser [Parameter] -> Parser [Parameter])
-> Parser [Parameter] -> Parser [Parameter]
forall a b. (a -> b) -> a -> b
$ Parser [Parameter] -> Parser [Parameter]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser [Parameter]
parseParams
  [Port]
_ <- (Identifier -> Port) -> [Identifier] -> [Port]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identifier -> Port
defaultPort ([Identifier] -> [Port])
-> Parser [Identifier] -> ParsecT [Token] () Identity [Port]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [Identifier]
parseModList
  TokenName -> Parser ()
tok' TokenName
SymSemi
  [ModItem ann]
modItem <- [ModItem ann]
-> ParsecT [Token] () Identity [ModItem ann]
-> ParsecT [Token] () Identity [ModItem ann]
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (ParsecT [Token] () Identity [ModItem ann]
 -> ParsecT [Token] () Identity [ModItem ann])
-> (ParsecT [Token] () Identity [ModItem ann]
    -> ParsecT [Token] () Identity [ModItem ann])
-> ParsecT [Token] () Identity [ModItem ann]
-> ParsecT [Token] () Identity [ModItem ann]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParsecT [Token] () Identity [ModItem ann]
-> ParsecT [Token] () Identity [ModItem ann]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT [Token] () Identity [ModItem ann]
 -> ParsecT [Token] () Identity [ModItem ann])
-> ParsecT [Token] () Identity [ModItem ann]
-> ParsecT [Token] () Identity [ModItem ann]
forall a b. (a -> b) -> a -> b
$ ParsecT [Token] () Identity (ModItem ann)
-> ParsecT [Token] () Identity [ModItem ann]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many1 ParsecT [Token] () Identity (ModItem ann)
forall ann. Parser (ModItem ann)
parseModItem
  TokenName -> Parser ()
tok' TokenName
KWEndmodule
  ModDecl ann -> Parser (ModDecl ann)
forall a. a -> ParsecT [Token] () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (ModDecl ann -> Parser (ModDecl ann))
-> ModDecl ann -> Parser (ModDecl ann)
forall a b. (a -> b) -> a -> b
$
    Identifier
-> [Port] -> [Port] -> [ModItem ann] -> [Parameter] -> ModDecl ann
forall a.
Identifier
-> [Port] -> [Port] -> [ModItem a] -> [Parameter] -> ModDecl a
ModDecl
      Identifier
name
      (PortDir -> [ModItem ann] -> [Port]
forall ann. PortDir -> [ModItem ann] -> [Port]
modPorts PortDir
PortOut [ModItem ann]
modItem)
      (PortDir -> [ModItem ann] -> [Port]
forall ann. PortDir -> [ModItem ann] -> [Port]
modPorts PortDir
PortIn [ModItem ann]
modItem)
      [ModItem ann]
modItem
      [Parameter]
paramList

mergeMaybe :: Maybe a -> Maybe a -> Maybe a
mergeMaybe :: forall a. Maybe a -> Maybe a -> Maybe a
mergeMaybe (Just a
a) Maybe a
Nothing = a -> Maybe a
forall a. a -> Maybe a
Just a
a
mergeMaybe Maybe a
Nothing (Just a
a) = a -> Maybe a
forall a. a -> Maybe a
Just a
a
mergeMaybe Maybe a
a Maybe a
_ = Maybe a
a

mergeType :: PortType -> PortType -> PortType
mergeType :: PortType -> PortType -> PortType
mergeType PortType
Reg PortType
Wire = PortType
Reg
mergeType PortType
Wire PortType
Reg = PortType
Reg
mergeType PortType
a PortType
_ = PortType
a

mergePorts :: Port -> Port -> Port
mergePorts :: Port -> Port -> Port
mergePorts (Port PortType
t1 Bool
s1 Range
r1 Identifier
n1) (Port PortType
t2 Bool
s2 Range
r2 Identifier
n2) =
  PortType -> Bool -> Range -> Identifier -> Port
Port (PortType -> PortType -> PortType
mergeType PortType
t1 PortType
t2) (Bool
s1 Bool -> Bool -> Bool
|| Bool
s2) (if Range
r1 Range -> Range -> Bool
forall a. Eq a => a -> a -> Bool
== Range
0 then Range
r2 else Range
r1) Identifier
n1

mergeIO :: ModItem a -> ModItem a -> ModItem a
mergeIO :: forall a. ModItem a -> ModItem a -> ModItem a
mergeIO (Decl Maybe PortDir
a1 Port
b1 Maybe ConstExpr
c1) (Decl Maybe PortDir
a2 Port
b2 Maybe ConstExpr
c2) = Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
forall a. Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
Decl (Maybe PortDir -> Maybe PortDir -> Maybe PortDir
forall a. Maybe a -> Maybe a -> Maybe a
mergeMaybe Maybe PortDir
a1 Maybe PortDir
a2) (Port -> Port -> Port
mergePorts Port
b1 Port
b2) (Maybe ConstExpr -> Maybe ConstExpr -> Maybe ConstExpr
forall a. Maybe a -> Maybe a -> Maybe a
mergeMaybe Maybe ConstExpr
c1 Maybe ConstExpr
c2)
mergeIO ModItem a
a ModItem a
_ = ModItem a
a

genmoditem :: Map.Map Identifier (ModItem a) -> ModItem a -> Map.Map Identifier (ModItem a)
genmoditem :: forall a.
Map Identifier (ModItem a)
-> ModItem a -> Map Identifier (ModItem a)
genmoditem Map Identifier (ModItem a)
m (Decl Maybe PortDir
a Port
b Maybe ConstExpr
c) =
  (ModItem a -> ModItem a -> ModItem a)
-> Identifier
-> ModItem a
-> Map Identifier (ModItem a)
-> Map Identifier (ModItem a)
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith ModItem a -> ModItem a -> ModItem a
forall a. ModItem a -> ModItem a -> ModItem a
mergeIO (Port
b Port -> Getting Identifier Port Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier Port Identifier
Lens' Port Identifier
portName) (Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
forall a. Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
Decl Maybe PortDir
a Port
b Maybe ConstExpr
c) Map Identifier (ModItem a)
m
genmoditem Map Identifier (ModItem a)
m ModItem a
b = Map Identifier (ModItem a)
m

modifyelements :: [ModItem a] -> [ModItem a]
modifyelements :: forall a. [ModItem a] -> [ModItem a]
modifyelements [ModItem a]
ma = [ModItem a]
ndecl [ModItem a] -> [ModItem a] -> [ModItem a]
forall a. Semigroup a => a -> a -> a
<> [ModItem a]
nodecl
  where
    ndecl :: [ModItem a]
ndecl = Map Identifier (ModItem a) -> [ModItem a]
forall k a. Map k a -> [a]
Map.elems (Map Identifier (ModItem a) -> [ModItem a])
-> Map Identifier (ModItem a) -> [ModItem a]
forall a b. (a -> b) -> a -> b
$ (Map Identifier (ModItem a)
 -> ModItem a -> Map Identifier (ModItem a))
-> Map Identifier (ModItem a)
-> [ModItem a]
-> Map Identifier (ModItem a)
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl Map Identifier (ModItem a)
-> ModItem a -> Map Identifier (ModItem a)
forall a.
Map Identifier (ModItem a)
-> ModItem a -> Map Identifier (ModItem a)
genmoditem Map Identifier (ModItem a)
forall k a. Map k a
Map.empty [ModItem a]
ma
    isDecl :: ModItem a -> Bool
isDecl Decl {} = Bool
True
    isDecl ModItem a
_ = Bool
False
    nodecl :: [ModItem a]
nodecl = (ModItem a -> Bool) -> [ModItem a] -> [ModItem a]
forall a. (a -> Bool) -> [a] -> [a]
filter ModItem a -> Bool
forall {a}. ModItem a -> Bool
isDecl [ModItem a]
ma

-- | Parses a 'String' into 'Verilog' by skipping any beginning whitespace
-- and then parsing multiple Verilog source.
parseVerilogSrc :: Parser (Verilog ann)
parseVerilogSrc :: forall ann. Parser (Verilog ann)
parseVerilogSrc = [ModDecl ann] -> Verilog ann
forall a. [ModDecl a] -> Verilog a
Verilog ([ModDecl ann] -> Verilog ann)
-> ParsecT [Token] () Identity [ModDecl ann]
-> ParsecT [Token] () Identity (Verilog ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Token] () Identity (ModDecl ann)
-> ParsecT [Token] () Identity [ModDecl ann]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT [Token] () Identity (ModDecl ann)
forall ann. Parser (ModDecl ann)
parseModDecl

-- | Parse a 'String' containing verilog code. The parser currently only supports
-- the subset of Verilog that is being generated randomly.
parseVerilog ::
  -- | Name of parsed object.
  Text ->
  -- | Content to be parsed.
  Text ->
  -- | Returns 'String' with error
  -- message if parse fails.
  Either Text (Verilog ann)
parseVerilog :: forall ann. Text -> Text -> Either Text (Verilog ann)
parseVerilog Text
s =
  (ParseError -> Text)
-> (Verilog ann -> Verilog ann)
-> Either ParseError (Verilog ann)
-> Either Text (Verilog ann)
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap ParseError -> Text
forall a. Show a => a -> Text
showT Verilog ann -> Verilog ann
forall a. a -> a
id -- (_Wrapped.traverse.modItems %~ modifyelements)
    (Either ParseError (Verilog ann) -> Either Text (Verilog ann))
-> (Text -> Either ParseError (Verilog ann))
-> Text
-> Either Text (Verilog ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parsec [Token] () (Verilog ann)
-> [Char] -> [Token] -> Either ParseError (Verilog ann)
forall s t a.
Stream s Identity t =>
Parsec s () a -> [Char] -> s -> Either ParseError a
parse Parsec [Token] () (Verilog ann)
forall ann. Parser (Verilog ann)
parseVerilogSrc (Text -> [Char]
T.unpack Text
s)
    ([Token] -> Either ParseError (Verilog ann))
-> (Text -> [Token]) -> Text -> Either ParseError (Verilog ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Token]
alexScanTokens
    ([Char] -> [Token]) -> (Text -> [Char]) -> Text -> [Token]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [([Char], [Char])] -> [Char] -> [Char] -> [Char]
preprocess [] (Text -> [Char]
T.unpack Text
s)
    ([Char] -> [Char]) -> (Text -> [Char]) -> Text -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
T.unpack

parseVerilogFile :: Text -> IO (Verilog ann)
parseVerilogFile :: forall ann. Text -> IO (Verilog ann)
parseVerilogFile Text
file = do
  Text
src <- [Char] -> IO Text
T.readFile ([Char] -> IO Text) -> [Char] -> IO Text
forall a b. (a -> b) -> a -> b
$ Text -> [Char]
T.unpack Text
file
  case Text -> Text -> Either Text (Verilog ann)
forall ann. Text -> Text -> Either Text (Verilog ann)
parseVerilog Text
file Text
src of
    Left Text
s -> [Char] -> IO (Verilog ann)
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO (Verilog ann)) -> [Char] -> IO (Verilog ann)
forall a b. (a -> b) -> a -> b
$ Text -> [Char]
T.unpack Text
s
    Right Verilog ann
r -> Verilog ann -> IO (Verilog ann)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Verilog ann
r

parseSourceInfoFile :: Text -> Text -> IO (SourceInfo ann)
parseSourceInfoFile :: forall ann. Text -> Text -> IO (SourceInfo ann)
parseSourceInfoFile Text
top = (Verilog ann -> SourceInfo ann)
-> IO (Verilog ann) -> IO (SourceInfo ann)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text -> Verilog ann -> SourceInfo ann
forall a. Text -> Verilog a -> SourceInfo a
SourceInfo Text
top) (IO (Verilog ann) -> IO (SourceInfo ann))
-> (Text -> IO (Verilog ann)) -> Text -> IO (SourceInfo ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> IO (Verilog ann)
forall ann. Text -> IO (Verilog ann)
parseVerilogFile