{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./CspCASL/SymbItems.hs
Description :  syntactic csp-casl symbols
Copyright   :  (c) Christian Maeder, DFKI GmbH 2011
License     :  GPLv2 or higher, see LICENSE.txt
Maintainer  :  Christian.Maeder@dfki.de
Stability   :  provisional
Portability :  portable

-}

module CspCASL.SymbItems where

import CspCASL.AS_CspCASL_Process
import CspCASL.CspCASL_Keywords
import CspCASL.Print_CspCASL
import CspCASL.Parse_CspCASL_Process

import CASL.AS_Basic_CASL
import CASL.SymbolParser
import CASL.ToDoc

import Common.AnnoState
import Common.Doc hiding (braces)
import Common.DocUtils
import Common.Id
import Common.Keywords
import Common.Lexer
import Common.Parsec
import Common.Token

import Text.ParserCombinators.Parsec

import Control.Monad
import Data.Data

import qualified Data.Set as Set

data CspSymbItems = CspSymbItems CspSymbKind [CspSymb]
  deriving (Int -> CspSymbItems -> ShowS
[CspSymbItems] -> ShowS
CspSymbItems -> String
(Int -> CspSymbItems -> ShowS)
-> (CspSymbItems -> String)
-> ([CspSymbItems] -> ShowS)
-> Show CspSymbItems
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CspSymbItems] -> ShowS
$cshowList :: [CspSymbItems] -> ShowS
show :: CspSymbItems -> String
$cshow :: CspSymbItems -> String
showsPrec :: Int -> CspSymbItems -> ShowS
$cshowsPrec :: Int -> CspSymbItems -> ShowS
Show, CspSymbItems -> CspSymbItems -> Bool
(CspSymbItems -> CspSymbItems -> Bool)
-> (CspSymbItems -> CspSymbItems -> Bool) -> Eq CspSymbItems
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CspSymbItems -> CspSymbItems -> Bool
$c/= :: CspSymbItems -> CspSymbItems -> Bool
== :: CspSymbItems -> CspSymbItems -> Bool
$c== :: CspSymbItems -> CspSymbItems -> Bool
Eq, Eq CspSymbItems
Eq CspSymbItems =>
(CspSymbItems -> CspSymbItems -> Ordering)
-> (CspSymbItems -> CspSymbItems -> Bool)
-> (CspSymbItems -> CspSymbItems -> Bool)
-> (CspSymbItems -> CspSymbItems -> Bool)
-> (CspSymbItems -> CspSymbItems -> Bool)
-> (CspSymbItems -> CspSymbItems -> CspSymbItems)
-> (CspSymbItems -> CspSymbItems -> CspSymbItems)
-> Ord CspSymbItems
CspSymbItems -> CspSymbItems -> Bool
CspSymbItems -> CspSymbItems -> Ordering
CspSymbItems -> CspSymbItems -> CspSymbItems
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CspSymbItems -> CspSymbItems -> CspSymbItems
$cmin :: CspSymbItems -> CspSymbItems -> CspSymbItems
max :: CspSymbItems -> CspSymbItems -> CspSymbItems
$cmax :: CspSymbItems -> CspSymbItems -> CspSymbItems
>= :: CspSymbItems -> CspSymbItems -> Bool
$c>= :: CspSymbItems -> CspSymbItems -> Bool
> :: CspSymbItems -> CspSymbItems -> Bool
$c> :: CspSymbItems -> CspSymbItems -> Bool
<= :: CspSymbItems -> CspSymbItems -> Bool
$c<= :: CspSymbItems -> CspSymbItems -> Bool
< :: CspSymbItems -> CspSymbItems -> Bool
$c< :: CspSymbItems -> CspSymbItems -> Bool
compare :: CspSymbItems -> CspSymbItems -> Ordering
$ccompare :: CspSymbItems -> CspSymbItems -> Ordering
$cp1Ord :: Eq CspSymbItems
Ord, Typeable, Typeable CspSymbItems
Constr
DataType
Typeable CspSymbItems =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CspSymbItems -> c CspSymbItems)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CspSymbItems)
-> (CspSymbItems -> Constr)
-> (CspSymbItems -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CspSymbItems))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CspSymbItems))
-> ((forall b. Data b => b -> b) -> CspSymbItems -> CspSymbItems)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CspSymbItems -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CspSymbItems -> r)
-> (forall u. (forall d. Data d => d -> u) -> CspSymbItems -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CspSymbItems -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CspSymbItems -> m CspSymbItems)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CspSymbItems -> m CspSymbItems)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CspSymbItems -> m CspSymbItems)
-> Data CspSymbItems
CspSymbItems -> Constr
CspSymbItems -> DataType
(forall b. Data b => b -> b) -> CspSymbItems -> CspSymbItems
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbItems -> c CspSymbItems
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbItems
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CspSymbItems -> u
forall u. (forall d. Data d => d -> u) -> CspSymbItems -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbItems -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbItems -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CspSymbItems -> m CspSymbItems
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymbItems -> m CspSymbItems
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbItems
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbItems -> c CspSymbItems
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspSymbItems)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CspSymbItems)
$cCspSymbItems :: Constr
$tCspSymbItems :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CspSymbItems -> m CspSymbItems
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymbItems -> m CspSymbItems
gmapMp :: (forall d. Data d => d -> m d) -> CspSymbItems -> m CspSymbItems
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymbItems -> m CspSymbItems
gmapM :: (forall d. Data d => d -> m d) -> CspSymbItems -> m CspSymbItems
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CspSymbItems -> m CspSymbItems
gmapQi :: Int -> (forall d. Data d => d -> u) -> CspSymbItems -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CspSymbItems -> u
gmapQ :: (forall d. Data d => d -> u) -> CspSymbItems -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CspSymbItems -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbItems -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbItems -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbItems -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbItems -> r
gmapT :: (forall b. Data b => b -> b) -> CspSymbItems -> CspSymbItems
$cgmapT :: (forall b. Data b => b -> b) -> CspSymbItems -> CspSymbItems
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CspSymbItems)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CspSymbItems)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CspSymbItems)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspSymbItems)
dataTypeOf :: CspSymbItems -> DataType
$cdataTypeOf :: CspSymbItems -> DataType
toConstr :: CspSymbItems -> Constr
$ctoConstr :: CspSymbItems -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbItems
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbItems
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbItems -> c CspSymbItems
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbItems -> c CspSymbItems
$cp1Data :: Typeable CspSymbItems
Data)

data CspSymbMapItems = CspSymbMapItems CspSymbKind [CspSymbMap]
  deriving (Int -> CspSymbMapItems -> ShowS
[CspSymbMapItems] -> ShowS
CspSymbMapItems -> String
(Int -> CspSymbMapItems -> ShowS)
-> (CspSymbMapItems -> String)
-> ([CspSymbMapItems] -> ShowS)
-> Show CspSymbMapItems
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CspSymbMapItems] -> ShowS
$cshowList :: [CspSymbMapItems] -> ShowS
show :: CspSymbMapItems -> String
$cshow :: CspSymbMapItems -> String
showsPrec :: Int -> CspSymbMapItems -> ShowS
$cshowsPrec :: Int -> CspSymbMapItems -> ShowS
Show, CspSymbMapItems -> CspSymbMapItems -> Bool
(CspSymbMapItems -> CspSymbMapItems -> Bool)
-> (CspSymbMapItems -> CspSymbMapItems -> Bool)
-> Eq CspSymbMapItems
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CspSymbMapItems -> CspSymbMapItems -> Bool
$c/= :: CspSymbMapItems -> CspSymbMapItems -> Bool
== :: CspSymbMapItems -> CspSymbMapItems -> Bool
$c== :: CspSymbMapItems -> CspSymbMapItems -> Bool
Eq, Eq CspSymbMapItems
Eq CspSymbMapItems =>
(CspSymbMapItems -> CspSymbMapItems -> Ordering)
-> (CspSymbMapItems -> CspSymbMapItems -> Bool)
-> (CspSymbMapItems -> CspSymbMapItems -> Bool)
-> (CspSymbMapItems -> CspSymbMapItems -> Bool)
-> (CspSymbMapItems -> CspSymbMapItems -> Bool)
-> (CspSymbMapItems -> CspSymbMapItems -> CspSymbMapItems)
-> (CspSymbMapItems -> CspSymbMapItems -> CspSymbMapItems)
-> Ord CspSymbMapItems
CspSymbMapItems -> CspSymbMapItems -> Bool
CspSymbMapItems -> CspSymbMapItems -> Ordering
CspSymbMapItems -> CspSymbMapItems -> CspSymbMapItems
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CspSymbMapItems -> CspSymbMapItems -> CspSymbMapItems
$cmin :: CspSymbMapItems -> CspSymbMapItems -> CspSymbMapItems
max :: CspSymbMapItems -> CspSymbMapItems -> CspSymbMapItems
$cmax :: CspSymbMapItems -> CspSymbMapItems -> CspSymbMapItems
>= :: CspSymbMapItems -> CspSymbMapItems -> Bool
$c>= :: CspSymbMapItems -> CspSymbMapItems -> Bool
> :: CspSymbMapItems -> CspSymbMapItems -> Bool
$c> :: CspSymbMapItems -> CspSymbMapItems -> Bool
<= :: CspSymbMapItems -> CspSymbMapItems -> Bool
$c<= :: CspSymbMapItems -> CspSymbMapItems -> Bool
< :: CspSymbMapItems -> CspSymbMapItems -> Bool
$c< :: CspSymbMapItems -> CspSymbMapItems -> Bool
compare :: CspSymbMapItems -> CspSymbMapItems -> Ordering
$ccompare :: CspSymbMapItems -> CspSymbMapItems -> Ordering
$cp1Ord :: Eq CspSymbMapItems
Ord, Typeable, Typeable CspSymbMapItems
Constr
DataType
Typeable CspSymbMapItems =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CspSymbMapItems -> c CspSymbMapItems)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CspSymbMapItems)
-> (CspSymbMapItems -> Constr)
-> (CspSymbMapItems -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CspSymbMapItems))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CspSymbMapItems))
-> ((forall b. Data b => b -> b)
    -> CspSymbMapItems -> CspSymbMapItems)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CspSymbMapItems -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CspSymbMapItems -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CspSymbMapItems -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CspSymbMapItems -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CspSymbMapItems -> m CspSymbMapItems)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CspSymbMapItems -> m CspSymbMapItems)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CspSymbMapItems -> m CspSymbMapItems)
-> Data CspSymbMapItems
CspSymbMapItems -> Constr
CspSymbMapItems -> DataType
(forall b. Data b => b -> b) -> CspSymbMapItems -> CspSymbMapItems
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbMapItems -> c CspSymbMapItems
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbMapItems
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> CspSymbMapItems -> u
forall u. (forall d. Data d => d -> u) -> CspSymbMapItems -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMapItems -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMapItems -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CspSymbMapItems -> m CspSymbMapItems
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CspSymbMapItems -> m CspSymbMapItems
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbMapItems
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbMapItems -> c CspSymbMapItems
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspSymbMapItems)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CspSymbMapItems)
$cCspSymbMapItems :: Constr
$tCspSymbMapItems :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> CspSymbMapItems -> m CspSymbMapItems
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CspSymbMapItems -> m CspSymbMapItems
gmapMp :: (forall d. Data d => d -> m d)
-> CspSymbMapItems -> m CspSymbMapItems
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CspSymbMapItems -> m CspSymbMapItems
gmapM :: (forall d. Data d => d -> m d)
-> CspSymbMapItems -> m CspSymbMapItems
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CspSymbMapItems -> m CspSymbMapItems
gmapQi :: Int -> (forall d. Data d => d -> u) -> CspSymbMapItems -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CspSymbMapItems -> u
gmapQ :: (forall d. Data d => d -> u) -> CspSymbMapItems -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CspSymbMapItems -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMapItems -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMapItems -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMapItems -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMapItems -> r
gmapT :: (forall b. Data b => b -> b) -> CspSymbMapItems -> CspSymbMapItems
$cgmapT :: (forall b. Data b => b -> b) -> CspSymbMapItems -> CspSymbMapItems
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CspSymbMapItems)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CspSymbMapItems)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CspSymbMapItems)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspSymbMapItems)
dataTypeOf :: CspSymbMapItems -> DataType
$cdataTypeOf :: CspSymbMapItems -> DataType
toConstr :: CspSymbMapItems -> Constr
$ctoConstr :: CspSymbMapItems -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbMapItems
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbMapItems
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbMapItems -> c CspSymbMapItems
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbMapItems -> c CspSymbMapItems
$cp1Data :: Typeable CspSymbMapItems
Data)

data CspSymbKind = CaslKind SYMB_KIND | ProcessKind | ChannelKind
  deriving (Int -> CspSymbKind -> ShowS
[CspSymbKind] -> ShowS
CspSymbKind -> String
(Int -> CspSymbKind -> ShowS)
-> (CspSymbKind -> String)
-> ([CspSymbKind] -> ShowS)
-> Show CspSymbKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CspSymbKind] -> ShowS
$cshowList :: [CspSymbKind] -> ShowS
show :: CspSymbKind -> String
$cshow :: CspSymbKind -> String
showsPrec :: Int -> CspSymbKind -> ShowS
$cshowsPrec :: Int -> CspSymbKind -> ShowS
Show, CspSymbKind -> CspSymbKind -> Bool
(CspSymbKind -> CspSymbKind -> Bool)
-> (CspSymbKind -> CspSymbKind -> Bool) -> Eq CspSymbKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CspSymbKind -> CspSymbKind -> Bool
$c/= :: CspSymbKind -> CspSymbKind -> Bool
== :: CspSymbKind -> CspSymbKind -> Bool
$c== :: CspSymbKind -> CspSymbKind -> Bool
Eq, Eq CspSymbKind
Eq CspSymbKind =>
(CspSymbKind -> CspSymbKind -> Ordering)
-> (CspSymbKind -> CspSymbKind -> Bool)
-> (CspSymbKind -> CspSymbKind -> Bool)
-> (CspSymbKind -> CspSymbKind -> Bool)
-> (CspSymbKind -> CspSymbKind -> Bool)
-> (CspSymbKind -> CspSymbKind -> CspSymbKind)
-> (CspSymbKind -> CspSymbKind -> CspSymbKind)
-> Ord CspSymbKind
CspSymbKind -> CspSymbKind -> Bool
CspSymbKind -> CspSymbKind -> Ordering
CspSymbKind -> CspSymbKind -> CspSymbKind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CspSymbKind -> CspSymbKind -> CspSymbKind
$cmin :: CspSymbKind -> CspSymbKind -> CspSymbKind
max :: CspSymbKind -> CspSymbKind -> CspSymbKind
$cmax :: CspSymbKind -> CspSymbKind -> CspSymbKind
>= :: CspSymbKind -> CspSymbKind -> Bool
$c>= :: CspSymbKind -> CspSymbKind -> Bool
> :: CspSymbKind -> CspSymbKind -> Bool
$c> :: CspSymbKind -> CspSymbKind -> Bool
<= :: CspSymbKind -> CspSymbKind -> Bool
$c<= :: CspSymbKind -> CspSymbKind -> Bool
< :: CspSymbKind -> CspSymbKind -> Bool
$c< :: CspSymbKind -> CspSymbKind -> Bool
compare :: CspSymbKind -> CspSymbKind -> Ordering
$ccompare :: CspSymbKind -> CspSymbKind -> Ordering
$cp1Ord :: Eq CspSymbKind
Ord, Typeable, Typeable CspSymbKind
Constr
DataType
Typeable CspSymbKind =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CspSymbKind -> c CspSymbKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CspSymbKind)
-> (CspSymbKind -> Constr)
-> (CspSymbKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CspSymbKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CspSymbKind))
-> ((forall b. Data b => b -> b) -> CspSymbKind -> CspSymbKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CspSymbKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CspSymbKind -> r)
-> (forall u. (forall d. Data d => d -> u) -> CspSymbKind -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CspSymbKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CspSymbKind -> m CspSymbKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CspSymbKind -> m CspSymbKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CspSymbKind -> m CspSymbKind)
-> Data CspSymbKind
CspSymbKind -> Constr
CspSymbKind -> DataType
(forall b. Data b => b -> b) -> CspSymbKind -> CspSymbKind
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbKind -> c CspSymbKind
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbKind
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CspSymbKind -> u
forall u. (forall d. Data d => d -> u) -> CspSymbKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CspSymbKind -> m CspSymbKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymbKind -> m CspSymbKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbKind -> c CspSymbKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspSymbKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CspSymbKind)
$cChannelKind :: Constr
$cProcessKind :: Constr
$cCaslKind :: Constr
$tCspSymbKind :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CspSymbKind -> m CspSymbKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymbKind -> m CspSymbKind
gmapMp :: (forall d. Data d => d -> m d) -> CspSymbKind -> m CspSymbKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymbKind -> m CspSymbKind
gmapM :: (forall d. Data d => d -> m d) -> CspSymbKind -> m CspSymbKind
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CspSymbKind -> m CspSymbKind
gmapQi :: Int -> (forall d. Data d => d -> u) -> CspSymbKind -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CspSymbKind -> u
gmapQ :: (forall d. Data d => d -> u) -> CspSymbKind -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CspSymbKind -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbKind -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbKind -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbKind -> r
gmapT :: (forall b. Data b => b -> b) -> CspSymbKind -> CspSymbKind
$cgmapT :: (forall b. Data b => b -> b) -> CspSymbKind -> CspSymbKind
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CspSymbKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CspSymbKind)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CspSymbKind)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspSymbKind)
dataTypeOf :: CspSymbKind -> DataType
$cdataTypeOf :: CspSymbKind -> DataType
toConstr :: CspSymbKind -> Constr
$ctoConstr :: CspSymbKind -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbKind
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbKind -> c CspSymbKind
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbKind -> c CspSymbKind
$cp1Data :: Typeable CspSymbKind
Data)

data CspSymb = CspSymb Id (Maybe CspType)
  deriving (Int -> CspSymb -> ShowS
[CspSymb] -> ShowS
CspSymb -> String
(Int -> CspSymb -> ShowS)
-> (CspSymb -> String) -> ([CspSymb] -> ShowS) -> Show CspSymb
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CspSymb] -> ShowS
$cshowList :: [CspSymb] -> ShowS
show :: CspSymb -> String
$cshow :: CspSymb -> String
showsPrec :: Int -> CspSymb -> ShowS
$cshowsPrec :: Int -> CspSymb -> ShowS
Show, CspSymb -> CspSymb -> Bool
(CspSymb -> CspSymb -> Bool)
-> (CspSymb -> CspSymb -> Bool) -> Eq CspSymb
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CspSymb -> CspSymb -> Bool
$c/= :: CspSymb -> CspSymb -> Bool
== :: CspSymb -> CspSymb -> Bool
$c== :: CspSymb -> CspSymb -> Bool
Eq, Eq CspSymb
Eq CspSymb =>
(CspSymb -> CspSymb -> Ordering)
-> (CspSymb -> CspSymb -> Bool)
-> (CspSymb -> CspSymb -> Bool)
-> (CspSymb -> CspSymb -> Bool)
-> (CspSymb -> CspSymb -> Bool)
-> (CspSymb -> CspSymb -> CspSymb)
-> (CspSymb -> CspSymb -> CspSymb)
-> Ord CspSymb
CspSymb -> CspSymb -> Bool
CspSymb -> CspSymb -> Ordering
CspSymb -> CspSymb -> CspSymb
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CspSymb -> CspSymb -> CspSymb
$cmin :: CspSymb -> CspSymb -> CspSymb
max :: CspSymb -> CspSymb -> CspSymb
$cmax :: CspSymb -> CspSymb -> CspSymb
>= :: CspSymb -> CspSymb -> Bool
$c>= :: CspSymb -> CspSymb -> Bool
> :: CspSymb -> CspSymb -> Bool
$c> :: CspSymb -> CspSymb -> Bool
<= :: CspSymb -> CspSymb -> Bool
$c<= :: CspSymb -> CspSymb -> Bool
< :: CspSymb -> CspSymb -> Bool
$c< :: CspSymb -> CspSymb -> Bool
compare :: CspSymb -> CspSymb -> Ordering
$ccompare :: CspSymb -> CspSymb -> Ordering
$cp1Ord :: Eq CspSymb
Ord, Typeable, Typeable CspSymb
Constr
DataType
Typeable CspSymb =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CspSymb -> c CspSymb)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CspSymb)
-> (CspSymb -> Constr)
-> (CspSymb -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CspSymb))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CspSymb))
-> ((forall b. Data b => b -> b) -> CspSymb -> CspSymb)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CspSymb -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CspSymb -> r)
-> (forall u. (forall d. Data d => d -> u) -> CspSymb -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CspSymb -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CspSymb -> m CspSymb)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CspSymb -> m CspSymb)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CspSymb -> m CspSymb)
-> Data CspSymb
CspSymb -> Constr
CspSymb -> DataType
(forall b. Data b => b -> b) -> CspSymb -> CspSymb
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymb -> c CspSymb
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymb
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CspSymb -> u
forall u. (forall d. Data d => d -> u) -> CspSymb -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymb -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymb -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CspSymb -> m CspSymb
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymb -> m CspSymb
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymb
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymb -> c CspSymb
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspSymb)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CspSymb)
$cCspSymb :: Constr
$tCspSymb :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CspSymb -> m CspSymb
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymb -> m CspSymb
gmapMp :: (forall d. Data d => d -> m d) -> CspSymb -> m CspSymb
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymb -> m CspSymb
gmapM :: (forall d. Data d => d -> m d) -> CspSymb -> m CspSymb
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CspSymb -> m CspSymb
gmapQi :: Int -> (forall d. Data d => d -> u) -> CspSymb -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CspSymb -> u
gmapQ :: (forall d. Data d => d -> u) -> CspSymb -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CspSymb -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymb -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymb -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymb -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymb -> r
gmapT :: (forall b. Data b => b -> b) -> CspSymb -> CspSymb
$cgmapT :: (forall b. Data b => b -> b) -> CspSymb -> CspSymb
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CspSymb)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CspSymb)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CspSymb)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspSymb)
dataTypeOf :: CspSymb -> DataType
$cdataTypeOf :: CspSymb -> DataType
toConstr :: CspSymb -> Constr
$ctoConstr :: CspSymb -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymb
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymb
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymb -> c CspSymb
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymb -> c CspSymb
$cp1Data :: Typeable CspSymb
Data)

-- for channels with sorts we may re-use A_type that is ambiguous
data CspType = CaslType TYPE | ProcType ProcProfile
  deriving (Int -> CspType -> ShowS
[CspType] -> ShowS
CspType -> String
(Int -> CspType -> ShowS)
-> (CspType -> String) -> ([CspType] -> ShowS) -> Show CspType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CspType] -> ShowS
$cshowList :: [CspType] -> ShowS
show :: CspType -> String
$cshow :: CspType -> String
showsPrec :: Int -> CspType -> ShowS
$cshowsPrec :: Int -> CspType -> ShowS
Show, CspType -> CspType -> Bool
(CspType -> CspType -> Bool)
-> (CspType -> CspType -> Bool) -> Eq CspType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CspType -> CspType -> Bool
$c/= :: CspType -> CspType -> Bool
== :: CspType -> CspType -> Bool
$c== :: CspType -> CspType -> Bool
Eq, Eq CspType
Eq CspType =>
(CspType -> CspType -> Ordering)
-> (CspType -> CspType -> Bool)
-> (CspType -> CspType -> Bool)
-> (CspType -> CspType -> Bool)
-> (CspType -> CspType -> Bool)
-> (CspType -> CspType -> CspType)
-> (CspType -> CspType -> CspType)
-> Ord CspType
CspType -> CspType -> Bool
CspType -> CspType -> Ordering
CspType -> CspType -> CspType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CspType -> CspType -> CspType
$cmin :: CspType -> CspType -> CspType
max :: CspType -> CspType -> CspType
$cmax :: CspType -> CspType -> CspType
>= :: CspType -> CspType -> Bool
$c>= :: CspType -> CspType -> Bool
> :: CspType -> CspType -> Bool
$c> :: CspType -> CspType -> Bool
<= :: CspType -> CspType -> Bool
$c<= :: CspType -> CspType -> Bool
< :: CspType -> CspType -> Bool
$c< :: CspType -> CspType -> Bool
compare :: CspType -> CspType -> Ordering
$ccompare :: CspType -> CspType -> Ordering
$cp1Ord :: Eq CspType
Ord, Typeable, Typeable CspType
Constr
DataType
Typeable CspType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CspType -> c CspType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CspType)
-> (CspType -> Constr)
-> (CspType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CspType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CspType))
-> ((forall b. Data b => b -> b) -> CspType -> CspType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CspType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CspType -> r)
-> (forall u. (forall d. Data d => d -> u) -> CspType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CspType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CspType -> m CspType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CspType -> m CspType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CspType -> m CspType)
-> Data CspType
CspType -> Constr
CspType -> DataType
(forall b. Data b => b -> b) -> CspType -> CspType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspType -> c CspType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CspType -> u
forall u. (forall d. Data d => d -> u) -> CspType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CspType -> m CspType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspType -> m CspType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspType -> c CspType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CspType)
$cProcType :: Constr
$cCaslType :: Constr
$tCspType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CspType -> m CspType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspType -> m CspType
gmapMp :: (forall d. Data d => d -> m d) -> CspType -> m CspType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspType -> m CspType
gmapM :: (forall d. Data d => d -> m d) -> CspType -> m CspType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CspType -> m CspType
gmapQi :: Int -> (forall d. Data d => d -> u) -> CspType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CspType -> u
gmapQ :: (forall d. Data d => d -> u) -> CspType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CspType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspType -> r
gmapT :: (forall b. Data b => b -> b) -> CspType -> CspType
$cgmapT :: (forall b. Data b => b -> b) -> CspType -> CspType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CspType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CspType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CspType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspType)
dataTypeOf :: CspType -> DataType
$cdataTypeOf :: CspType -> DataType
toConstr :: CspType -> Constr
$ctoConstr :: CspType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspType -> c CspType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspType -> c CspType
$cp1Data :: Typeable CspType
Data)

data CspSymbMap = CspSymbMap CspSymb (Maybe CspSymb)
  deriving (Int -> CspSymbMap -> ShowS
[CspSymbMap] -> ShowS
CspSymbMap -> String
(Int -> CspSymbMap -> ShowS)
-> (CspSymbMap -> String)
-> ([CspSymbMap] -> ShowS)
-> Show CspSymbMap
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CspSymbMap] -> ShowS
$cshowList :: [CspSymbMap] -> ShowS
show :: CspSymbMap -> String
$cshow :: CspSymbMap -> String
showsPrec :: Int -> CspSymbMap -> ShowS
$cshowsPrec :: Int -> CspSymbMap -> ShowS
Show, CspSymbMap -> CspSymbMap -> Bool
(CspSymbMap -> CspSymbMap -> Bool)
-> (CspSymbMap -> CspSymbMap -> Bool) -> Eq CspSymbMap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CspSymbMap -> CspSymbMap -> Bool
$c/= :: CspSymbMap -> CspSymbMap -> Bool
== :: CspSymbMap -> CspSymbMap -> Bool
$c== :: CspSymbMap -> CspSymbMap -> Bool
Eq, Eq CspSymbMap
Eq CspSymbMap =>
(CspSymbMap -> CspSymbMap -> Ordering)
-> (CspSymbMap -> CspSymbMap -> Bool)
-> (CspSymbMap -> CspSymbMap -> Bool)
-> (CspSymbMap -> CspSymbMap -> Bool)
-> (CspSymbMap -> CspSymbMap -> Bool)
-> (CspSymbMap -> CspSymbMap -> CspSymbMap)
-> (CspSymbMap -> CspSymbMap -> CspSymbMap)
-> Ord CspSymbMap
CspSymbMap -> CspSymbMap -> Bool
CspSymbMap -> CspSymbMap -> Ordering
CspSymbMap -> CspSymbMap -> CspSymbMap
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CspSymbMap -> CspSymbMap -> CspSymbMap
$cmin :: CspSymbMap -> CspSymbMap -> CspSymbMap
max :: CspSymbMap -> CspSymbMap -> CspSymbMap
$cmax :: CspSymbMap -> CspSymbMap -> CspSymbMap
>= :: CspSymbMap -> CspSymbMap -> Bool
$c>= :: CspSymbMap -> CspSymbMap -> Bool
> :: CspSymbMap -> CspSymbMap -> Bool
$c> :: CspSymbMap -> CspSymbMap -> Bool
<= :: CspSymbMap -> CspSymbMap -> Bool
$c<= :: CspSymbMap -> CspSymbMap -> Bool
< :: CspSymbMap -> CspSymbMap -> Bool
$c< :: CspSymbMap -> CspSymbMap -> Bool
compare :: CspSymbMap -> CspSymbMap -> Ordering
$ccompare :: CspSymbMap -> CspSymbMap -> Ordering
$cp1Ord :: Eq CspSymbMap
Ord, Typeable, Typeable CspSymbMap
Constr
DataType
Typeable CspSymbMap =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CspSymbMap -> c CspSymbMap)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CspSymbMap)
-> (CspSymbMap -> Constr)
-> (CspSymbMap -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CspSymbMap))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CspSymbMap))
-> ((forall b. Data b => b -> b) -> CspSymbMap -> CspSymbMap)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CspSymbMap -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CspSymbMap -> r)
-> (forall u. (forall d. Data d => d -> u) -> CspSymbMap -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CspSymbMap -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CspSymbMap -> m CspSymbMap)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CspSymbMap -> m CspSymbMap)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CspSymbMap -> m CspSymbMap)
-> Data CspSymbMap
CspSymbMap -> Constr
CspSymbMap -> DataType
(forall b. Data b => b -> b) -> CspSymbMap -> CspSymbMap
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbMap -> c CspSymbMap
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbMap
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CspSymbMap -> u
forall u. (forall d. Data d => d -> u) -> CspSymbMap -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMap -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMap -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CspSymbMap -> m CspSymbMap
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymbMap -> m CspSymbMap
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbMap
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbMap -> c CspSymbMap
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspSymbMap)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CspSymbMap)
$cCspSymbMap :: Constr
$tCspSymbMap :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CspSymbMap -> m CspSymbMap
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymbMap -> m CspSymbMap
gmapMp :: (forall d. Data d => d -> m d) -> CspSymbMap -> m CspSymbMap
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CspSymbMap -> m CspSymbMap
gmapM :: (forall d. Data d => d -> m d) -> CspSymbMap -> m CspSymbMap
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CspSymbMap -> m CspSymbMap
gmapQi :: Int -> (forall d. Data d => d -> u) -> CspSymbMap -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CspSymbMap -> u
gmapQ :: (forall d. Data d => d -> u) -> CspSymbMap -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CspSymbMap -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMap -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMap -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMap -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CspSymbMap -> r
gmapT :: (forall b. Data b => b -> b) -> CspSymbMap -> CspSymbMap
$cgmapT :: (forall b. Data b => b -> b) -> CspSymbMap -> CspSymbMap
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CspSymbMap)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CspSymbMap)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CspSymbMap)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CspSymbMap)
dataTypeOf :: CspSymbMap -> DataType
$cdataTypeOf :: CspSymbMap -> DataType
toConstr :: CspSymbMap -> Constr
$ctoConstr :: CspSymbMap -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbMap
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CspSymbMap
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbMap -> c CspSymbMap
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CspSymbMap -> c CspSymbMap
$cp1Data :: Typeable CspSymbMap
Data)

pluralCspSympKind :: CspSymbKind -> [a] -> Doc
pluralCspSympKind :: CspSymbKind -> [a] -> Doc
pluralCspSympKind k :: CspSymbKind
k l :: [a]
l = case CspSymbKind
k of
    CaslKind c :: SYMB_KIND
c -> case SYMB_KIND
c of
      Implicit -> Doc
empty
      _ -> String -> Doc
keyword (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ SYMB_KIND -> [a] -> String
forall a. SYMB_KIND -> [a] -> String
pluralS_symb_list SYMB_KIND
c [a]
l
    ProcessKind -> String -> Doc
keyword String
processS
    ChannelKind -> String -> Doc
keyword (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ String
channelS String -> ShowS
forall a. [a] -> [a] -> [a]
++ [a] -> String
forall a. [a] -> String
appendS [a]
l

instance Pretty CspSymbKind where
  pretty :: CspSymbKind -> Doc
pretty k :: CspSymbKind
k = CspSymbKind -> [()] -> Doc
forall a. CspSymbKind -> [a] -> Doc
pluralCspSympKind CspSymbKind
k [()]

instance Pretty CspType where
  pretty :: CspType -> Doc
pretty t :: CspType
t = case CspType
t of
    CaslType c :: TYPE
c -> Doc
colon Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> TYPE -> Doc
forall a. Pretty a => a -> Doc
pretty TYPE
c
    ProcType p :: ProcProfile
p -> ProcProfile -> Doc
printProcProfile ProcProfile
p

instance Pretty CspSymb where
  pretty :: CspSymb -> Doc
pretty (CspSymb i :: Id
i ms :: Maybe CspType
ms) = Id -> Doc
forall a. Pretty a => a -> Doc
pretty Id
i Doc -> Doc -> Doc
<+> Maybe CspType -> Doc
forall a. Pretty a => a -> Doc
pretty Maybe CspType
ms

instance Pretty CspSymbMap where
  pretty :: CspSymbMap -> Doc
pretty (CspSymbMap s :: CspSymb
s ms :: Maybe CspSymb
ms) = CspSymb -> Doc
forall a. Pretty a => a -> Doc
pretty CspSymb
s Doc -> Doc -> Doc
<+> case Maybe CspSymb
ms of
    Nothing -> Doc
empty
    Just t :: CspSymb
t -> Doc
mapsto Doc -> Doc -> Doc
<+> CspSymb -> Doc
forall a. Pretty a => a -> Doc
pretty CspSymb
t

instance Pretty CspSymbItems where
  pretty :: CspSymbItems -> Doc
pretty (CspSymbItems k :: CspSymbKind
k l :: [CspSymb]
l) = CspSymbKind -> [CspSymb] -> Doc
forall a. CspSymbKind -> [a] -> Doc
pluralCspSympKind CspSymbKind
k [CspSymb]
l Doc -> Doc -> Doc
<+> [CspSymb] -> Doc
forall a. Pretty a => [a] -> Doc
ppWithCommas [CspSymb]
l

instance Pretty CspSymbMapItems where
  pretty :: CspSymbMapItems -> Doc
pretty (CspSymbMapItems k :: CspSymbKind
k l :: [CspSymbMap]
l) = CspSymbKind -> [CspSymbMap] -> Doc
forall a. CspSymbKind -> [a] -> Doc
pluralCspSympKind CspSymbKind
k [CspSymbMap]
l Doc -> Doc -> Doc
<+> [CspSymbMap] -> Doc
forall a. Pretty a => [a] -> Doc
ppWithCommas [CspSymbMap]
l

commAlpha :: AParser st CommAlpha
commAlpha :: AParser st CommAlpha
commAlpha = ([CommType] -> CommAlpha)
-> ParsecT String (AnnoState st) Identity [CommType]
-> AParser st CommAlpha
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [CommType] -> CommAlpha
forall a. Ord a => [a] -> Set a
Set.fromList (ParsecT String (AnnoState st) Identity [CommType]
 -> AParser st CommAlpha)
-> ParsecT String (AnnoState st) Identity [CommType]
-> AParser st CommAlpha
forall a b. (a -> b) -> a -> b
$ ParsecT String (AnnoState st) Identity CommType
-> ParsecT String (AnnoState st) Identity [CommType]
forall (m :: * -> *) a. Monad m => m a -> m [a]
single ParsecT String (AnnoState st) Identity CommType
forall st. AParser st CommType
commType ParsecT String (AnnoState st) Identity [CommType]
-> ParsecT String (AnnoState st) Identity [CommType]
-> ParsecT String (AnnoState st) Identity [CommType]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String (AnnoState st) Identity [CommType]
forall st. AParser st [CommType]
bracedList

-- | parsing a possibly qualified identifier
cspSymb :: AParser st CspSymb
cspSymb :: AParser st CspSymb
cspSymb =
    do Id
i <- AParser st Id
forall st. AParser st Id
parseCspId
       do
         Token
_ <- GenParser Char (AnnoState st) Token
forall st. GenParser Char st Token
colonST
         CspType
t <- (TYPE -> CspType)
-> ParsecT String (AnnoState st) Identity TYPE
-> ParsecT String (AnnoState st) Identity CspType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TYPE -> CspType
CaslType ([String] -> ParsecT String (AnnoState st) Identity TYPE
forall st. [String] -> AParser st TYPE
opOrPredType [String]
cspKeywords) ParsecT String (AnnoState st) Identity CspType
-> ParsecT String (AnnoState st) Identity CspType
-> ParsecT String (AnnoState st) Identity CspType
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
            (CommAlpha -> CspType)
-> ParsecT String (AnnoState st) Identity CommAlpha
-> ParsecT String (AnnoState st) Identity CspType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ProcProfile -> CspType
ProcType (ProcProfile -> CspType)
-> (CommAlpha -> ProcProfile) -> CommAlpha -> CspType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PROC_ARGS -> CommAlpha -> ProcProfile
ProcProfile []) ParsecT String (AnnoState st) Identity CommAlpha
forall st. AParser st CommAlpha
commAlpha
         CspSymb -> AParser st CspSymb
forall (m :: * -> *) a. Monad m => a -> m a
return (CspSymb -> AParser st CspSymb) -> CspSymb -> AParser st CspSymb
forall a b. (a -> b) -> a -> b
$ Id -> Maybe CspType -> CspSymb
CspSymb Id
i (Maybe CspType -> CspSymb) -> Maybe CspType -> CspSymb
forall a b. (a -> b) -> a -> b
$ CspType -> Maybe CspType
forall a. a -> Maybe a
Just CspType
t
        AParser st CspSymb -> AParser st CspSymb -> AParser st CspSymb
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
         PROC_ARGS
ts <- AParser st Id -> AParser st PROC_ARGS
forall st a. AParser st a -> AParser st [a]
parenList AParser st Id
forall st. AParser st Id
cspSortId
         GenParser Char (AnnoState st) Token
forall st. AParser st Token
colonT
         CommAlpha
cs <- ParsecT String (AnnoState st) Identity CommAlpha
forall st. AParser st CommAlpha
commAlpha
         CspSymb -> AParser st CspSymb
forall (m :: * -> *) a. Monad m => a -> m a
return (CspSymb -> AParser st CspSymb) -> CspSymb -> AParser st CspSymb
forall a b. (a -> b) -> a -> b
$ Id -> Maybe CspType -> CspSymb
CspSymb Id
i (Maybe CspType -> CspSymb) -> Maybe CspType -> CspSymb
forall a b. (a -> b) -> a -> b
$ CspType -> Maybe CspType
forall a. a -> Maybe a
Just (CspType -> Maybe CspType) -> CspType -> Maybe CspType
forall a b. (a -> b) -> a -> b
$ ProcProfile -> CspType
ProcType (ProcProfile -> CspType) -> ProcProfile -> CspType
forall a b. (a -> b) -> a -> b
$ PROC_ARGS -> CommAlpha -> ProcProfile
ProcProfile PROC_ARGS
ts CommAlpha
cs
        AParser st CspSymb -> AParser st CspSymb -> AParser st CspSymb
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> CspSymb -> AParser st CspSymb
forall (m :: * -> *) a. Monad m => a -> m a
return (Id -> Maybe CspType -> CspSymb
CspSymb Id
i Maybe CspType
forall a. Maybe a
Nothing)

-- | parsing one symbol or a mapping of one to second symbol
cspSymbMap :: AParser st CspSymbMap
cspSymbMap :: AParser st CspSymbMap
cspSymbMap = (CspSymb -> Maybe CspSymb -> CspSymbMap)
-> ParsecT String (AnnoState st) Identity CspSymb
-> ParsecT String (AnnoState st) Identity (Maybe CspSymb)
-> AParser st CspSymbMap
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 CspSymb -> Maybe CspSymb -> CspSymbMap
CspSymbMap ParsecT String (AnnoState st) Identity CspSymb
forall st. AParser st CspSymb
cspSymb (ParsecT String (AnnoState st) Identity (Maybe CspSymb)
 -> AParser st CspSymbMap)
-> ParsecT String (AnnoState st) Identity (Maybe CspSymb)
-> AParser st CspSymbMap
forall a b. (a -> b) -> a -> b
$ ParsecT String (AnnoState st) Identity CspSymb
-> ParsecT String (AnnoState st) Identity (Maybe CspSymb)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe
  (ParsecT String (AnnoState st) Identity CspSymb
 -> ParsecT String (AnnoState st) Identity (Maybe CspSymb))
-> ParsecT String (AnnoState st) Identity CspSymb
-> ParsecT String (AnnoState st) Identity (Maybe CspSymb)
forall a b. (a -> b) -> a -> b
$ String -> AParser st Token
forall st. String -> AParser st Token
asKey String
mapsTo AParser st Token
-> ParsecT String (AnnoState st) Identity ()
-> ParsecT String (AnnoState st) Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT String (AnnoState st) Identity CspSymbKind
-> ParsecT String (AnnoState st) Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional ParsecT String (AnnoState st) Identity CspSymbKind
forall st. AParser st CspSymbKind
cspSymbKind ParsecT String (AnnoState st) Identity ()
-> ParsecT String (AnnoState st) Identity CspSymb
-> ParsecT String (AnnoState st) Identity CspSymb
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT String (AnnoState st) Identity CspSymb
forall st. AParser st CspSymb
cspSymb

-- | parse a kind keyword
cspSymbKind :: AParser st CspSymbKind
cspSymbKind :: AParser st CspSymbKind
cspSymbKind =
  (Token -> CspSymbKind)
-> ParsecT String (AnnoState st) Identity Token
-> AParser st CspSymbKind
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (CspSymbKind -> Token -> CspSymbKind
forall a b. a -> b -> a
const CspSymbKind
ChannelKind) (String -> ParsecT String (AnnoState st) Identity Token
forall st. String -> CharParser st Token
pluralKeyword String
channelS)
  AParser st CspSymbKind
-> AParser st CspSymbKind -> AParser st CspSymbKind
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Token -> CspSymbKind)
-> ParsecT String (AnnoState st) Identity Token
-> AParser st CspSymbKind
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (CspSymbKind -> Token -> CspSymbKind
forall a b. a -> b -> a
const CspSymbKind
ProcessKind) (String -> ParsecT String (AnnoState st) Identity Token
forall st. String -> AParser st Token
asKey String
processS)
  AParser st CspSymbKind
-> AParser st CspSymbKind -> AParser st CspSymbKind
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ((SYMB_KIND, Token) -> CspSymbKind)
-> ParsecT String (AnnoState st) Identity (SYMB_KIND, Token)
-> AParser st CspSymbKind
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (SYMB_KIND -> CspSymbKind
CaslKind (SYMB_KIND -> CspSymbKind)
-> ((SYMB_KIND, Token) -> SYMB_KIND)
-> (SYMB_KIND, Token)
-> CspSymbKind
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SYMB_KIND, Token) -> SYMB_KIND
forall a b. (a, b) -> a
fst) ParsecT String (AnnoState st) Identity (SYMB_KIND, Token)
forall st. AParser st (SYMB_KIND, Token)
symbKind

-- | parse a comma separated list of symbols
cspSymbs :: AParser st [CspSymb]
cspSymbs :: AParser st [CspSymb]
cspSymbs =
    do CspSymb
s <- AParser st CspSymb
forall st. AParser st CspSymb
cspSymb
       do
         Token
_ <- CharParser (AnnoState st) Token
forall st. GenParser Char st Token
commaT CharParser (AnnoState st) Token
-> GenParser Char (AnnoState st) Id
-> CharParser (AnnoState st) Token
forall tok st a b.
GenParser tok st a -> GenParser tok st b -> GenParser tok st a
`followedWith` GenParser Char (AnnoState st) Id
forall st. AParser st Id
parseCspId
         [CspSymb]
is <- AParser st [CspSymb]
forall st. AParser st [CspSymb]
cspSymbs
         [CspSymb] -> AParser st [CspSymb]
forall (m :: * -> *) a. Monad m => a -> m a
return ([CspSymb] -> AParser st [CspSymb])
-> [CspSymb] -> AParser st [CspSymb]
forall a b. (a -> b) -> a -> b
$ CspSymb
s CspSymb -> [CspSymb] -> [CspSymb]
forall a. a -> [a] -> [a]
: [CspSymb]
is
        AParser st [CspSymb]
-> AParser st [CspSymb] -> AParser st [CspSymb]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> [CspSymb] -> AParser st [CspSymb]
forall (m :: * -> *) a. Monad m => a -> m a
return [CspSymb
s]

{- | Parse a possible kinded list of comma separated CspCASL symbols.
     The argument is a list of keywords to avoid as identifiers. -}
cspSymbItems :: AParser st CspSymbItems
cspSymbItems :: AParser st CspSymbItems
cspSymbItems = ([CspSymb] -> CspSymbItems)
-> ParsecT String (AnnoState st) Identity [CspSymb]
-> AParser st CspSymbItems
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (CspSymbKind -> [CspSymb] -> CspSymbItems
CspSymbItems (CspSymbKind -> [CspSymb] -> CspSymbItems)
-> CspSymbKind -> [CspSymb] -> CspSymbItems
forall a b. (a -> b) -> a -> b
$ SYMB_KIND -> CspSymbKind
CaslKind SYMB_KIND
Implicit) ParsecT String (AnnoState st) Identity [CspSymb]
forall st. AParser st [CspSymb]
cspSymbs AParser st CspSymbItems
-> AParser st CspSymbItems -> AParser st CspSymbItems
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
    CspSymbKind
k <- AParser st CspSymbKind
forall st. AParser st CspSymbKind
cspSymbKind
    ([CspSymb] -> CspSymbItems)
-> ParsecT String (AnnoState st) Identity [CspSymb]
-> AParser st CspSymbItems
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (CspSymbKind -> [CspSymb] -> CspSymbItems
CspSymbItems CspSymbKind
k) ParsecT String (AnnoState st) Identity [CspSymb]
forall st. AParser st [CspSymb]
cspSymbs

-- | parse a comma separated list of symbols
cspSymbMaps :: AParser st [CspSymbMap]
cspSymbMaps :: AParser st [CspSymbMap]
cspSymbMaps =
    do CspSymbMap
s <- AParser st CspSymbMap
forall st. AParser st CspSymbMap
cspSymbMap
       do
         Token
_ <- CharParser (AnnoState st) Token
forall st. GenParser Char st Token
commaT CharParser (AnnoState st) Token
-> GenParser Char (AnnoState st) Id
-> CharParser (AnnoState st) Token
forall tok st a b.
GenParser tok st a -> GenParser tok st b -> GenParser tok st a
`followedWith` GenParser Char (AnnoState st) Id
forall st. AParser st Id
parseCspId
         [CspSymbMap]
is <- AParser st [CspSymbMap]
forall st. AParser st [CspSymbMap]
cspSymbMaps
         [CspSymbMap] -> AParser st [CspSymbMap]
forall (m :: * -> *) a. Monad m => a -> m a
return ([CspSymbMap] -> AParser st [CspSymbMap])
-> [CspSymbMap] -> AParser st [CspSymbMap]
forall a b. (a -> b) -> a -> b
$ CspSymbMap
s CspSymbMap -> [CspSymbMap] -> [CspSymbMap]
forall a. a -> [a] -> [a]
: [CspSymbMap]
is
        AParser st [CspSymbMap]
-> AParser st [CspSymbMap] -> AParser st [CspSymbMap]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> [CspSymbMap] -> AParser st [CspSymbMap]
forall (m :: * -> *) a. Monad m => a -> m a
return [CspSymbMap
s]

-- | parse a possible kinded list of CspCASL symbol mappings
cspSymbMapItems :: AParser st CspSymbMapItems
cspSymbMapItems :: AParser st CspSymbMapItems
cspSymbMapItems = ([CspSymbMap] -> CspSymbMapItems)
-> ParsecT String (AnnoState st) Identity [CspSymbMap]
-> AParser st CspSymbMapItems
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (CspSymbKind -> [CspSymbMap] -> CspSymbMapItems
CspSymbMapItems (CspSymbKind -> [CspSymbMap] -> CspSymbMapItems)
-> CspSymbKind -> [CspSymbMap] -> CspSymbMapItems
forall a b. (a -> b) -> a -> b
$ SYMB_KIND -> CspSymbKind
CaslKind SYMB_KIND
Implicit) ParsecT String (AnnoState st) Identity [CspSymbMap]
forall st. AParser st [CspSymbMap]
cspSymbMaps
  AParser st CspSymbMapItems
-> AParser st CspSymbMapItems -> AParser st CspSymbMapItems
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
    CspSymbKind
k <- AParser st CspSymbKind
forall st. AParser st CspSymbKind
cspSymbKind
    ([CspSymbMap] -> CspSymbMapItems)
-> ParsecT String (AnnoState st) Identity [CspSymbMap]
-> AParser st CspSymbMapItems
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (CspSymbKind -> [CspSymbMap] -> CspSymbMapItems
CspSymbMapItems CspSymbKind
k) ParsecT String (AnnoState st) Identity [CspSymbMap]
forall st. AParser st [CspSymbMap]
cspSymbMaps