{- |
Module      :  ./Propositional/Parse_AS_Basic.hs
Description :  Parser for basic specs
Copyright   :  (c) Dominik Luecke, Uni Bremen 2007
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  luecke@informatik.uni-bremen.de
Stability   :  experimental
Portability :  portable

Parser for abstract syntax for propositional logic

  Ref.
  <http://en.wikipedia.org/wiki/Propositional_logic>
-}

module Propositional.Parse_AS_Basic
  ( basicSpec                      -- Parser for basic specs
  , symbItems
  , symbMapItems
  , impFormula
  ) where

import Common.AnnoState
import Common.AS_Annotation
import Common.Id
import Common.Keywords
import Common.Lexer
import Common.Token
import Common.Parsec
import Common.GlobalAnnotations (PrefixMap)

import Propositional.AS_BASIC_Propositional as AS_BASIC
import Text.ParserCombinators.Parsec

propKeywords :: [String]
propKeywords :: [String]
propKeywords = [String]
criticalKeywords [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++
  [ String
propS
  , String
notS
  , String
trueS
  , String
falseS ]

-- | Toplevel parser for basic specs
basicSpec :: PrefixMap -> AParser st AS_BASIC.BASIC_SPEC
basicSpec :: PrefixMap -> AParser st BASIC_SPEC
basicSpec _ =
  ([Annoted BASIC_ITEMS] -> BASIC_SPEC)
-> ParsecT String (AnnoState st) Identity [Annoted BASIC_ITEMS]
-> AParser st BASIC_SPEC
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Annoted BASIC_ITEMS] -> BASIC_SPEC
AS_BASIC.Basic_spec (AParser st BASIC_ITEMS
-> ParsecT String (AnnoState st) Identity [Annoted BASIC_ITEMS]
forall st a. AParser st a -> AParser st [Annoted a]
annosParser AParser st BASIC_ITEMS
forall st. AParser st BASIC_ITEMS
parseBasicItems)
  AParser st BASIC_SPEC
-> AParser st BASIC_SPEC -> AParser st BASIC_SPEC
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (CharParser (AnnoState st) Token
forall st. CharParser st Token
oBraceT CharParser (AnnoState st) Token
-> CharParser (AnnoState st) Token
-> CharParser (AnnoState st) Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CharParser (AnnoState st) Token
forall st. CharParser st Token
cBraceT CharParser (AnnoState st) Token
-> AParser st BASIC_SPEC -> AParser st BASIC_SPEC
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BASIC_SPEC -> AParser st BASIC_SPEC
forall (m :: * -> *) a. Monad m => a -> m a
return ([Annoted BASIC_ITEMS] -> BASIC_SPEC
AS_BASIC.Basic_spec []))

-- | Parser for basic items
parseBasicItems :: AParser st AS_BASIC.BASIC_ITEMS
parseBasicItems :: AParser st BASIC_ITEMS
parseBasicItems = AParser st BASIC_ITEMS
forall st. AParser st BASIC_ITEMS
parsePredDecl AParser st BASIC_ITEMS
-> AParser st BASIC_ITEMS -> AParser st BASIC_ITEMS
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> AParser st BASIC_ITEMS
forall st. AParser st BASIC_ITEMS
parseAxItems

-- | parser for predicate declarations
parsePredDecl :: AParser st AS_BASIC.BASIC_ITEMS
parsePredDecl :: AParser st BASIC_ITEMS
parsePredDecl = (PRED_ITEM -> BASIC_ITEMS)
-> ParsecT String (AnnoState st) Identity PRED_ITEM
-> AParser st BASIC_ITEMS
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PRED_ITEM -> BASIC_ITEMS
AS_BASIC.Pred_decl ParsecT String (AnnoState st) Identity PRED_ITEM
forall st. AParser st PRED_ITEM
predItem

-- | parser for Axiom_items
parseAxItems :: AParser st AS_BASIC.BASIC_ITEMS
parseAxItems :: AParser st BASIC_ITEMS
parseAxItems = do
       Token
d <- AParser st Token
forall st. AParser st Token
dotT
       (fs :: [Annoted FORMULA]
fs, ds :: [Token]
ds) <- AParser st (Annoted FORMULA)
forall st. AParser st (Annoted FORMULA)
aFormula AParser st (Annoted FORMULA)
-> AParser st Token
-> GenParser Char (AnnoState st) ([Annoted FORMULA], [Token])
forall tok st a b.
GenParser tok st a
-> GenParser tok st b -> GenParser tok st ([a], [b])
`separatedBy` AParser st Token
forall st. AParser st Token
dotT
       (_, an :: [Annotation]
an) <- AParser st ([Token], [Annotation])
forall st. AParser st ([Token], [Annotation])
optSemi
       let Range
_ = [Token] -> Range
catRange (Token
d Token -> [Token] -> [Token]
forall a. a -> [a] -> [a]
: [Token]
ds)
           ns :: [Annoted FORMULA]
ns = [Annoted FORMULA] -> [Annoted FORMULA]
forall a. [a] -> [a]
init [Annoted FORMULA]
fs [Annoted FORMULA] -> [Annoted FORMULA] -> [Annoted FORMULA]
forall a. [a] -> [a] -> [a]
++ [Annoted FORMULA -> [Annotation] -> Annoted FORMULA
forall a. Annoted a -> [Annotation] -> Annoted a
appendAnno ([Annoted FORMULA] -> Annoted FORMULA
forall a. [a] -> a
last [Annoted FORMULA]
fs) [Annotation]
an]
       BASIC_ITEMS -> AParser st BASIC_ITEMS
forall (m :: * -> *) a. Monad m => a -> m a
return (BASIC_ITEMS -> AParser st BASIC_ITEMS)
-> BASIC_ITEMS -> AParser st BASIC_ITEMS
forall a b. (a -> b) -> a -> b
$ [Annoted FORMULA] -> BASIC_ITEMS
AS_BASIC.Axiom_items [Annoted FORMULA]
ns

-- | Any word to token
propId :: GenParser Char st Token
propId :: GenParser Char st Token
propId = CharParser st String -> GenParser Char st Token
forall st. CharParser st String -> CharParser st Token
pToken (CharParser st String -> GenParser Char st Token)
-> CharParser st String -> GenParser Char st Token
forall a b. (a -> b) -> a -> b
$ [String] -> CharParser st String -> CharParser st String
forall st. [String] -> CharParser st String -> CharParser st String
reserved [String]
propKeywords CharParser st String
forall st. CharParser st String
scanAnyWords

-- | parser for predicates = propositions
predItem :: AParser st AS_BASIC.PRED_ITEM
predItem :: AParser st PRED_ITEM
predItem = do
      Token
v <- String -> AParser st Token
forall st. String -> AParser st Token
asKey (String
propS String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
sS) AParser st Token -> AParser st Token -> AParser st Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
           String -> AParser st Token
forall st. String -> AParser st Token
asKey String
propS
      (ps :: [Token]
ps, cs :: [Token]
cs) <- AParser st Token
forall st. CharParser st Token
propId AParser st Token
-> AParser st Token
-> GenParser Char (AnnoState st) ([Token], [Token])
forall tok st a b.
GenParser tok st a
-> GenParser tok st b -> GenParser tok st ([a], [b])
`separatedBy` AParser st Token
forall st. AParser st Token
anComma
      PRED_ITEM -> AParser st PRED_ITEM
forall (m :: * -> *) a. Monad m => a -> m a
return (PRED_ITEM -> AParser st PRED_ITEM)
-> PRED_ITEM -> AParser st PRED_ITEM
forall a b. (a -> b) -> a -> b
$ [Token] -> Range -> PRED_ITEM
AS_BASIC.Pred_item [Token]
ps (Range -> PRED_ITEM) -> Range -> PRED_ITEM
forall a b. (a -> b) -> a -> b
$ [Token] -> Range
catRange ([Token] -> Range) -> [Token] -> Range
forall a b. (a -> b) -> a -> b
$ Token
v Token -> [Token] -> [Token]
forall a. a -> [a] -> [a]
: [Token]
cs

-- | Parser for implies @=>@
implKey :: AParser st Token
implKey :: AParser st Token
implKey = String -> AParser st Token
forall st. String -> AParser st Token
asKey String
implS

-- | Parser for and @\/\ @
andKey :: AParser st Token
andKey :: AParser st Token
andKey = String -> AParser st Token
forall st. String -> AParser st Token
asKey String
lAnd

-- | Parser for or @\\\/@
orKey :: AParser st Token
orKey :: AParser st Token
orKey = String -> AParser st Token
forall st. String -> AParser st Token
asKey String
lOr

-- | Parser for true
trueKey :: AParser st Token
trueKey :: AParser st Token
trueKey = String -> AParser st Token
forall st. String -> AParser st Token
asKey String
trueS

-- | Parser for false
falseKey :: AParser st Token
falseKey :: AParser st Token
falseKey = String -> AParser st Token
forall st. String -> AParser st Token
asKey String
falseS

-- | Parser for not
notKey :: AParser st Token
notKey :: AParser st Token
notKey = String -> AParser st Token
forall st. String -> AParser st Token
asKey String
notS

-- | Parser for negation
negKey :: AParser st Token
negKey :: AParser st Token
negKey = String -> AParser st Token
forall st. String -> AParser st Token
asKey String
negS

-- | Parser for equivalence @<=>@
equivKey :: AParser st Token
equivKey :: AParser st Token
equivKey = String -> AParser st Token
forall st. String -> AParser st Token
asKey String
equivS

-- | Parser for primitive formulae
primFormula :: AParser st AS_BASIC.FORMULA
primFormula :: AParser st FORMULA
primFormula =
    do Token
c <- AParser st Token
forall st. AParser st Token
trueKey
       FORMULA -> AParser st FORMULA
forall (m :: * -> *) a. Monad m => a -> m a
return (Range -> FORMULA
AS_BASIC.True_atom (Range -> FORMULA) -> Range -> FORMULA
forall a b. (a -> b) -> a -> b
$ Token -> Range
tokPos Token
c)
    AParser st FORMULA -> AParser st FORMULA -> AParser st FORMULA
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    do Token
c <- AParser st Token
forall st. AParser st Token
falseKey
       FORMULA -> AParser st FORMULA
forall (m :: * -> *) a. Monad m => a -> m a
return (Range -> FORMULA
AS_BASIC.False_atom (Range -> FORMULA) -> Range -> FORMULA
forall a b. (a -> b) -> a -> b
$ Token -> Range
tokPos Token
c)
    AParser st FORMULA -> AParser st FORMULA -> AParser st FORMULA
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    do Token
c <- AParser st Token
forall st. AParser st Token
notKey AParser st Token -> AParser st Token -> AParser st Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> AParser st Token
forall st. AParser st Token
negKey AParser st Token -> String -> AParser st Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> "\"not\""
       FORMULA
k <- AParser st FORMULA
forall st. AParser st FORMULA
primFormula
       FORMULA -> AParser st FORMULA
forall (m :: * -> *) a. Monad m => a -> m a
return (FORMULA -> Range -> FORMULA
AS_BASIC.Negation FORMULA
k (Range -> FORMULA) -> Range -> FORMULA
forall a b. (a -> b) -> a -> b
$ Token -> Range
tokPos Token
c)
    AParser st FORMULA -> AParser st FORMULA -> AParser st FORMULA
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> AParser st FORMULA
forall st. AParser st FORMULA
parenFormula
    AParser st FORMULA -> AParser st FORMULA -> AParser st FORMULA
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Token -> FORMULA) -> AParser st Token -> AParser st FORMULA
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Token -> FORMULA
AS_BASIC.Predication AParser st Token
forall st. CharParser st Token
propId

-- | Parser for formulae containing 'and' and 'or'
andOrFormula :: AParser st AS_BASIC.FORMULA
andOrFormula :: AParser st FORMULA
andOrFormula = do
  FORMULA
f <- AParser st FORMULA
forall st. AParser st FORMULA
primFormula
  do Token
c <- AParser st Token
forall st. AParser st Token
andKey
     (fs :: [FORMULA]
fs, ps :: [Token]
ps) <- AParser st FORMULA
forall st. AParser st FORMULA
primFormula AParser st FORMULA
-> AParser st Token
-> GenParser Char (AnnoState st) ([FORMULA], [Token])
forall tok st a b.
GenParser tok st a
-> GenParser tok st b -> GenParser tok st ([a], [b])
`separatedBy` AParser st Token
forall st. AParser st Token
andKey
     FORMULA -> AParser st FORMULA
forall (m :: * -> *) a. Monad m => a -> m a
return (FORMULA -> AParser st FORMULA)
-> ([Token] -> FORMULA) -> [Token] -> AParser st FORMULA
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [FORMULA] -> Range -> FORMULA
AS_BASIC.Conjunction (FORMULA
f FORMULA -> [FORMULA] -> [FORMULA]
forall a. a -> [a] -> [a]
: [FORMULA]
fs) (Range -> FORMULA) -> ([Token] -> Range) -> [Token] -> FORMULA
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Token] -> Range
catRange ([Token] -> AParser st FORMULA) -> [Token] -> AParser st FORMULA
forall a b. (a -> b) -> a -> b
$ Token
c Token -> [Token] -> [Token]
forall a. a -> [a] -> [a]
: [Token]
ps
   AParser st FORMULA -> AParser st FORMULA -> AParser st FORMULA
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
     Token
c <- AParser st Token
forall st. AParser st Token
orKey
     (fs :: [FORMULA]
fs, ps :: [Token]
ps) <- AParser st FORMULA
forall st. AParser st FORMULA
primFormula AParser st FORMULA
-> AParser st Token
-> GenParser Char (AnnoState st) ([FORMULA], [Token])
forall tok st a b.
GenParser tok st a
-> GenParser tok st b -> GenParser tok st ([a], [b])
`separatedBy` AParser st Token
forall st. AParser st Token
orKey
     FORMULA -> AParser st FORMULA
forall (m :: * -> *) a. Monad m => a -> m a
return (FORMULA -> AParser st FORMULA)
-> ([Token] -> FORMULA) -> [Token] -> AParser st FORMULA
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [FORMULA] -> Range -> FORMULA
AS_BASIC.Disjunction (FORMULA
f FORMULA -> [FORMULA] -> [FORMULA]
forall a. a -> [a] -> [a]
: [FORMULA]
fs) (Range -> FORMULA) -> ([Token] -> Range) -> [Token] -> FORMULA
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Token] -> Range
catRange ([Token] -> AParser st FORMULA) -> [Token] -> AParser st FORMULA
forall a b. (a -> b) -> a -> b
$ Token
c Token -> [Token] -> [Token]
forall a. a -> [a] -> [a]
: [Token]
ps
   AParser st FORMULA -> AParser st FORMULA -> AParser st FORMULA
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> FORMULA -> AParser st FORMULA
forall (m :: * -> *) a. Monad m => a -> m a
return FORMULA
f

-- | Parser for formulae with implications
impFormula :: AParser st AS_BASIC.FORMULA
impFormula :: AParser st FORMULA
impFormula = do
  FORMULA
f <- AParser st FORMULA
forall st. AParser st FORMULA
andOrFormula
  do Token
c <- AParser st Token
forall st. AParser st Token
implKey
     (fs :: [FORMULA]
fs, ps :: [Token]
ps) <- AParser st FORMULA
forall st. AParser st FORMULA
andOrFormula AParser st FORMULA
-> AParser st Token
-> GenParser Char (AnnoState st) ([FORMULA], [Token])
forall tok st a b.
GenParser tok st a
-> GenParser tok st b -> GenParser tok st ([a], [b])
`separatedBy` AParser st Token
forall st. AParser st Token
implKey
     FORMULA -> AParser st FORMULA
forall (m :: * -> *) a. Monad m => a -> m a
return (FORMULA -> AParser st FORMULA)
-> ([Token] -> FORMULA) -> [Token] -> AParser st FORMULA
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [FORMULA] -> [Pos] -> FORMULA
makeImpl (FORMULA
f FORMULA -> [FORMULA] -> [FORMULA]
forall a. a -> [a] -> [a]
: [FORMULA]
fs) ([Pos] -> FORMULA) -> ([Token] -> [Pos]) -> [Token] -> FORMULA
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Token] -> [Pos]
catPosAux ([Token] -> AParser st FORMULA) -> [Token] -> AParser st FORMULA
forall a b. (a -> b) -> a -> b
$ Token
c Token -> [Token] -> [Token]
forall a. a -> [a] -> [a]
: [Token]
ps
   AParser st FORMULA -> AParser st FORMULA -> AParser st FORMULA
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
     Token
c <- AParser st Token
forall st. AParser st Token
equivKey
     FORMULA
g <- AParser st FORMULA
forall st. AParser st FORMULA
andOrFormula
     FORMULA -> AParser st FORMULA
forall (m :: * -> *) a. Monad m => a -> m a
return (FORMULA -> AParser st FORMULA)
-> (Range -> FORMULA) -> Range -> AParser st FORMULA
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FORMULA -> FORMULA -> Range -> FORMULA
AS_BASIC.Equivalence FORMULA
f FORMULA
g (Range -> AParser st FORMULA) -> Range -> AParser st FORMULA
forall a b. (a -> b) -> a -> b
$ Token -> Range
tokPos Token
c
   AParser st FORMULA -> AParser st FORMULA -> AParser st FORMULA
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> FORMULA -> AParser st FORMULA
forall (m :: * -> *) a. Monad m => a -> m a
return FORMULA
f
  where
  makeImpl :: [FORMULA] -> [Pos] -> FORMULA
makeImpl [f :: FORMULA
f, g :: FORMULA
g] p :: [Pos]
p = FORMULA -> FORMULA -> Range -> FORMULA
AS_BASIC.Implication FORMULA
f FORMULA
g ([Pos] -> Range
Range [Pos]
p)
  makeImpl (f :: FORMULA
f : r :: [FORMULA]
r) (c :: Pos
c : p :: [Pos]
p) = FORMULA -> FORMULA -> Range -> FORMULA
AS_BASIC.Implication FORMULA
f ([FORMULA] -> [Pos] -> FORMULA
makeImpl [FORMULA]
r [Pos]
p) ([Pos] -> Range
Range [Pos
c])
  makeImpl _ _ = String -> FORMULA
forall a. HasCallStack => String -> a
error "makeImpl got illegal argument"

-- | Parser for formulae with parentheses
parenFormula :: AParser st AS_BASIC.FORMULA
parenFormula :: AParser st FORMULA
parenFormula = do
       CharParser (AnnoState st) Token
forall st. CharParser st Token
oParenT CharParser (AnnoState st) Token
-> ParsecT String (AnnoState st) Identity ()
-> CharParser (AnnoState st) Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
<< ParsecT String (AnnoState st) Identity ()
forall st. AParser st ()
addAnnos
       FORMULA
f <- AParser st FORMULA
forall st. AParser st FORMULA
impFormula AParser st FORMULA
-> ParsecT String (AnnoState st) Identity () -> AParser st FORMULA
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
<< ParsecT String (AnnoState st) Identity ()
forall st. AParser st ()
addAnnos
       CharParser (AnnoState st) Token
forall st. CharParser st Token
cParenT CharParser (AnnoState st) Token
-> AParser st FORMULA -> AParser st FORMULA
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> FORMULA -> AParser st FORMULA
forall (m :: * -> *) a. Monad m => a -> m a
return FORMULA
f

-- | Toplevel parser for formulae
aFormula :: AParser st (Annoted AS_BASIC.FORMULA)
aFormula :: AParser st (Annoted FORMULA)
aFormula = AParser st FORMULA -> AParser st (Annoted FORMULA)
forall st a. AParser st a -> AParser st (Annoted a)
allAnnoParser AParser st FORMULA
forall st. AParser st FORMULA
impFormula

-- | parsing a prop symbol
symb :: GenParser Char st SYMB
symb :: GenParser Char st SYMB
symb = (Token -> SYMB)
-> ParsecT String st Identity Token -> GenParser Char st SYMB
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Token -> SYMB
Symb_id ParsecT String st Identity Token
forall st. CharParser st Token
propId

-- | parsing one symbol or a mapping of one to a second symbol
symbMap :: GenParser Char st SYMB_OR_MAP
symbMap :: GenParser Char st SYMB_OR_MAP
symbMap = do
  SYMB
s <- GenParser Char st SYMB
forall st. GenParser Char st SYMB
symb
  do Token
f <- CharParser st String -> CharParser st Token
forall st. CharParser st String -> CharParser st Token
pToken (CharParser st String -> CharParser st Token)
-> CharParser st String -> CharParser st Token
forall a b. (a -> b) -> a -> b
$ String -> CharParser st String
forall st. String -> CharParser st String
toKey String
mapsTo
     SYMB
t <- GenParser Char st SYMB
forall st. GenParser Char st SYMB
symb
     SYMB_OR_MAP -> GenParser Char st SYMB_OR_MAP
forall (m :: * -> *) a. Monad m => a -> m a
return (SYMB -> SYMB -> Range -> SYMB_OR_MAP
Symb_map SYMB
s SYMB
t (Range -> SYMB_OR_MAP) -> Range -> SYMB_OR_MAP
forall a b. (a -> b) -> a -> b
$ Token -> Range
tokPos Token
f)
    GenParser Char st SYMB_OR_MAP
-> GenParser Char st SYMB_OR_MAP -> GenParser Char st SYMB_OR_MAP
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> SYMB_OR_MAP -> GenParser Char st SYMB_OR_MAP
forall (m :: * -> *) a. Monad m => a -> m a
return (SYMB -> SYMB_OR_MAP
Symb SYMB
s)

-- | Parse a list of comma separated symbols.
symbItems :: GenParser Char st SYMB_ITEMS
symbItems :: GenParser Char st SYMB_ITEMS
symbItems = do
  (is :: [SYMB]
is, ps :: [Token]
ps) <- GenParser Char st ([SYMB], [Token])
forall st. GenParser Char st ([SYMB], [Token])
symbs
  SYMB_ITEMS -> GenParser Char st SYMB_ITEMS
forall (m :: * -> *) a. Monad m => a -> m a
return ([SYMB] -> Range -> SYMB_ITEMS
Symb_items [SYMB]
is (Range -> SYMB_ITEMS) -> Range -> SYMB_ITEMS
forall a b. (a -> b) -> a -> b
$ [Token] -> Range
catRange [Token]
ps)

-- | parse a comma separated list of symbols
symbs :: GenParser Char st ([SYMB], [Token])
symbs :: GenParser Char st ([SYMB], [Token])
symbs = do
       SYMB
s <- GenParser Char st SYMB
forall st. GenParser Char st SYMB
symb
       do Token
c <- CharParser st Token
forall st. CharParser st Token
commaT CharParser st Token
-> GenParser Char st SYMB -> CharParser st Token
forall tok st a b.
GenParser tok st a -> GenParser tok st b -> GenParser tok st a
`followedWith` GenParser Char st SYMB
forall st. GenParser Char st SYMB
symb
          (is :: [SYMB]
is, ps :: [Token]
ps) <- GenParser Char st ([SYMB], [Token])
forall st. GenParser Char st ([SYMB], [Token])
symbs
          ([SYMB], [Token]) -> GenParser Char st ([SYMB], [Token])
forall (m :: * -> *) a. Monad m => a -> m a
return (SYMB
s SYMB -> [SYMB] -> [SYMB]
forall a. a -> [a] -> [a]
: [SYMB]
is, Token
c Token -> [Token] -> [Token]
forall a. a -> [a] -> [a]
: [Token]
ps)
         GenParser Char st ([SYMB], [Token])
-> GenParser Char st ([SYMB], [Token])
-> GenParser Char st ([SYMB], [Token])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ([SYMB], [Token]) -> GenParser Char st ([SYMB], [Token])
forall (m :: * -> *) a. Monad m => a -> m a
return ([SYMB
s], [])

-- | parse a list of symbol mappings
symbMapItems :: GenParser Char st SYMB_MAP_ITEMS
symbMapItems :: GenParser Char st SYMB_MAP_ITEMS
symbMapItems = do
  (is :: [SYMB_OR_MAP]
is, ps :: [Token]
ps) <- GenParser Char st ([SYMB_OR_MAP], [Token])
forall st. GenParser Char st ([SYMB_OR_MAP], [Token])
symbMaps
  SYMB_MAP_ITEMS -> GenParser Char st SYMB_MAP_ITEMS
forall (m :: * -> *) a. Monad m => a -> m a
return ([SYMB_OR_MAP] -> Range -> SYMB_MAP_ITEMS
Symb_map_items [SYMB_OR_MAP]
is (Range -> SYMB_MAP_ITEMS) -> Range -> SYMB_MAP_ITEMS
forall a b. (a -> b) -> a -> b
$ [Token] -> Range
catRange [Token]
ps)

-- | parse a comma separated list of symbol mappings
symbMaps :: GenParser Char st ([SYMB_OR_MAP], [Token])
symbMaps :: GenParser Char st ([SYMB_OR_MAP], [Token])
symbMaps = do
  SYMB_OR_MAP
s <- GenParser Char st SYMB_OR_MAP
forall st. GenParser Char st SYMB_OR_MAP
symbMap
  do Token
c <- CharParser st Token
forall st. CharParser st Token
commaT CharParser st Token
-> GenParser Char st SYMB -> CharParser st Token
forall tok st a b.
GenParser tok st a -> GenParser tok st b -> GenParser tok st a
`followedWith` GenParser Char st SYMB
forall st. GenParser Char st SYMB
symb
     (is :: [SYMB_OR_MAP]
is, ps :: [Token]
ps) <- GenParser Char st ([SYMB_OR_MAP], [Token])
forall st. GenParser Char st ([SYMB_OR_MAP], [Token])
symbMaps
     ([SYMB_OR_MAP], [Token])
-> GenParser Char st ([SYMB_OR_MAP], [Token])
forall (m :: * -> *) a. Monad m => a -> m a
return (SYMB_OR_MAP
s SYMB_OR_MAP -> [SYMB_OR_MAP] -> [SYMB_OR_MAP]
forall a. a -> [a] -> [a]
: [SYMB_OR_MAP]
is, Token
c Token -> [Token] -> [Token]
forall a. a -> [a] -> [a]
: [Token]
ps)
    GenParser Char st ([SYMB_OR_MAP], [Token])
-> GenParser Char st ([SYMB_OR_MAP], [Token])
-> GenParser Char st ([SYMB_OR_MAP], [Token])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ([SYMB_OR_MAP], [Token])
-> GenParser Char st ([SYMB_OR_MAP], [Token])
forall (m :: * -> *) a. Monad m => a -> m a
return ([SYMB_OR_MAP
s], [])