----------------------------------------------------------------------------
-- Parsers for CSP-CASL-specifications
----------------------------------------------------------------------------
interim :: AParser st C3PO
interim = try ( do { nc <- namedCspCaslCSpec
<|> do { c <- cspCaslCSpec
namedCspCaslCSpec :: AParser st NAMED_CSP_CASL_C_SPEC
namedCspCaslCSpec = try ( do { ccspecT
; return (Named_csp_casl_spec n c)
; return (Named_csp_casl_spec n c)
specName :: AParser st SPEC_NAME
cspCaslCSpec :: AParser st CSP_CASL_C_SPEC
cspCaslCSpec = do { d <- dataDefn
; return (Csp_casl_c_spec d c p)
; return (Csp_casl_c_spec d c p)
basicCspCaslCSpec :: AParser st Basic_CSP_CASL_C_SPEC
basicCspCaslCSpec = do { c <- channelDecl
; return (Basic_csp_casl_c_spec c p)
----------------------------------------------------------------------------
----------------------------------------------------------------------------
dataDefn :: AParser st DATA_DEFN
; d <- basicSpec csp_casl_keywords
channelDecl :: AParser st CHANNEL_DECL
channelDecl = do { channelT
; (cs, ps) <- channelItem `separatedBy` semicolonT
; return (Channel_items cs)
channelItem :: AParser st CHANNEL_ITEM
channelItem = do { (ns, ps) <- channelName `separatedBy` commaT
; s <- sortId csp_casl_keywords
; return (Channel_decl ns s)
processDefn :: AParser st PROCESS_DEFN
processDefn = try ( do { processT
; (pe, ps) <- processEquation `separatedBy` semicolonT
; return (Recursive pe np)
; (pe, ps) <- processEquation `separatedBy` semicolonT
; gnp <- genericNamedProcess
; return (Generic_recursive pe gnp)
processEquation :: AParser st PROCESS_EQUATION
processEquation = try ( do { np <- namedProcess
<|> do { ge <- genericEquation
; return (Generic_equation ge p)
genericEquation :: AParser st GENERIC_EQUATION
genericEquation = do { pn <- processName
; return (Generic pn vi es)
-- closing bracket missing!!
genericNamedProcess :: AParser st GEN_NAMED_PROCESS
genericNamedProcess = do { pn <- processName
; t <- term csp_casl_keywords
; return (Generic_named pn t)
namedProcess :: AParser st NAMED_PROCESS
namedProcess = do { pn <- processName
-- MiniParser via Umbennung; eventuell Passenderes w�hlen
processName :: AParser st PROCESS_NAME
channelId :: AParser st Token
primProcess :: AParser st PROCESS
; f <- formula csp_casl_keywords
; return (Conditional_choice f p1 p2)
; f <- formula csp_casl_keywords
; return (Conditional_process f p)
; f <- formula csp_casl_keywords
; return (Guarded_command f p)
; return (Multiple_prefix v es p)
<|> try ( do { e <- event
<|> try ( do { gnp <- genericNamedProcess
; return (Generic_named_process gnp)
<|> do { np <- namedProcess
; return (Named_process np)
-- ; return (Guarded f p)
--renamedProcess :: AParser st PROCESS
--renamedProcess = try (do { p <- primProcess
-- <|> do { p <- primProcess
seqProcess :: AParser st PROCESS
seqProcess = try ( do { rp <- hidRenProcess
; return (Sequential [rp, sp])
<|> do { hrp <- hidRenProcess
sortRenaming :: AParser st SORT_RENAMING
sortRenaming = do { (procs, ps) <- opList `separatedBy` commaT
channelRenaming :: AParser st CHANNEL_RENAMING
channelRenaming = do { cn1 <- channelName
; return (Channel_renaming cn1 cn2)
hidRenProcess :: AParser st PROCESS
hidRenProcess = try ( do { pp <- primProcess
<|> try ( do { pp <- primProcess
; return (Csp_sort_renaming pp sr)
<|> try ( do { pp <- primProcess
; return (Csp_channel_renaming pp sr)
<|> do { pp <- primProcess
intChoiceProcess :: AParser st PROCESS
intChoiceProcess = try ( do { sp <- seqProcess
; icp <- intChoiceProcess
; return (Internal_choice [sp, icp])
<|> do { sp <- seqProcess
extChoiceProcess :: AParser st PROCESS
extChoiceProcess = try ( do { sp <- seqProcess
; ecp <- extChoiceProcess
; return (External_choice [sp, ecp])
<|> do { sp <- seqProcess
choiceProcess :: AParser st PROCESS
choiceProcess = try ( do { sp <- seqProcess
; ecp <- extChoiceProcess
; return (External_choice [sp, ecp])
<|> try ( do { sp <- seqProcess
; icp <- intChoiceProcess
; return (Internal_choice [sp, icp])
<|> do { sp <- seqProcess
synParaProcess :: AParser st PROCESS
synParaProcess = try ( do { cp <- choiceProcess
; return (Synchronous_parallel [cp, spp])
<|> do { cp <- choiceProcess
interParaProcess :: AParser st PROCESS
interParaProcess = try ( do { cp <- choiceProcess
; ipp <- interParaProcess
; return (Interleaving_parallel [cp, ipp])
<|> do { cp <- choiceProcess
process :: AParser st PROCESS
process = try ( do { cp <- choiceProcess
; return (Synchronous_parallel [cp, spp])
<|> try ( do { cp <- choiceProcess
; ipp <- interParaProcess
; return (Interleaving_parallel [cp, ipp])
<|> try ( do { cp1 <- choiceProcess
; return (General_parallel cp1 es1 es2 cp2)
<|> try ( do { cp1 <- choiceProcess
; return (Alphabet_parallel cp1 es cp2)
<|> do { ch <- choiceProcess
opList :: AParser st OP_NAME
opList = do { pid <- parseId csp_casl_keywords
eventSet :: AParser st EVENT_SET
eventSet = do { si <- sortId csp_casl_keywords
event :: AParser st EVENT
event = try (do { ci <- channelId
; t <- term csp_casl_keywords
<|> try (do { ci <- channelId
; si <- sortId csp_casl_keywords
; return (Receive ci v si)
<|> do { t <- term csp_casl_keywords
namedProcess :: GenParser Char st PROCESS
namedProcess = do { pn <- sortId
; return (Named_process pn)
<|> try ( do { (procs, ps) <- choiceProcess `separatedBy` interParaT
; return (if length procs == 1 then head procs
else Interleaving_parallel procs)