-- | Read PGF files created with GF 3.5 and a few older releases
module PGF.OldBinary(getPGF,getPGF',version) where

import PGF.CId
import PGF.Data
import PGF.Optimize
import Data.Binary
import Data.Binary.Get
import Data.Array.IArray
import qualified Data.Map as Map
import qualified Data.IntMap as IntMap
import qualified Data.Set as Set
import Control.Monad

pgfMajorVersion, pgfMinorVersion :: Word16
version :: (Word16, Word16)
version@(Word16
pgfMajorVersion, Word16
pgfMinorVersion) = (Word16
1,Word16
0)

getPGF :: Get PGF
getPGF = do Word16
v1 <- Get Word16
getWord16be
            Word16
v2 <- Get Word16
getWord16be
            let v :: (Word16, Word16)
v=(Word16
v1,Word16
v2)
            if (Word16, Word16)
v(Word16, Word16) -> (Word16, Word16) -> Bool
forall a. Eq a => a -> a -> Bool
==(Word16, Word16)
version 
              then Get PGF
getPGF'
              else [Char] -> Get PGF
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
decodingError ([Char]
"version "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++(Word16, Word16) -> [Char]
forall a. Show a => a -> [Char]
show (Word16, Word16)
v[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"/="[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++(Word16, Word16) -> [Char]
forall a. Show a => a -> [Char]
show (Word16, Word16)
version)

getPGF' :: Get PGF
getPGF'=do Map CId Literal
gflags <- Get (Map CId Literal)
getFlags
           CId
absname <- Get CId
getCId
           Abstr
abstract <- Get Abstr
getAbstract
           Map CId Concr
concretes <- Get CId -> Get Concr -> Get (Map CId Concr)
forall k a. Get k -> Get a -> Get (Map k a)
getMap Get CId
getCId Get Concr
getConcr
           PGF -> Get PGF
forall (m :: * -> *) a. Monad m => a -> m a
return (PGF -> Get PGF) -> PGF -> Get PGF
forall a b. (a -> b) -> a -> b
$ PGF -> PGF
updateProductionIndices (PGF -> PGF) -> PGF -> PGF
forall a b. (a -> b) -> a -> b
$
                      (PGF :: Map CId Literal -> CId -> Abstr -> Map CId Concr -> PGF
PGF{ gflags :: Map CId Literal
gflags=Map CId Literal
gflags
                          , absname :: CId
absname=CId
absname, abstract :: Abstr
abstract=Abstr
abstract
                          , concretes :: Map CId Concr
concretes=Map CId Concr
concretes
                          })

getCId :: Get CId
getCId = (ByteString -> CId) -> Get ByteString -> Get CId
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM ByteString -> CId
CId Get ByteString
forall t. Binary t => Get t
get

getAbstract :: Get Abstr
getAbstract =
        do Map CId Literal
aflags <- Get (Map CId Literal)
getFlags
           Map CId (Type, Int, Maybe [Equation], Double)
funs <- Get CId
-> Get (Type, Int, Maybe [Equation], Double)
-> Get (Map CId (Type, Int, Maybe [Equation], Double))
forall k a. Get k -> Get a -> Get (Map k a)
getMap Get CId
getCId Get (Type, Int, Maybe [Equation], Double)
getFun
           Map CId ([Hypo], [(Double, CId)])
cats <- Get CId
-> Get ([Hypo], [(Double, CId)])
-> Get (Map CId ([Hypo], [(Double, CId)]))
forall k a. Get k -> Get a -> Get (Map k a)
getMap Get CId
getCId Get ([Hypo], [(Double, CId)])
getCat
           Abstr -> Get Abstr
forall (m :: * -> *) a. Monad m => a -> m a
return (Abstr :: Map CId Literal
-> Map CId (Type, Int, Maybe ([Equation], [[Instr]]), Double)
-> Map CId ([Hypo], [(Double, CId)], Double)
-> Abstr
Abstr{ aflags :: Map CId Literal
aflags=Map CId Literal
aflags
                        , funs :: Map CId (Type, Int, Maybe ([Equation], [[Instr]]), Double)
funs=((Type, Int, Maybe [Equation], Double)
 -> (Type, Int, Maybe ([Equation], [[Instr]]), Double))
-> Map CId (Type, Int, Maybe [Equation], Double)
-> Map CId (Type, Int, Maybe ([Equation], [[Instr]]), Double)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Type
w,Int
x,Maybe [Equation]
y,Double
z) -> (Type
w,Int
x,([Equation] -> ([Equation], [[Instr]]))
-> Maybe [Equation] -> Maybe ([Equation], [[Instr]])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (([Equation] -> [[Instr]] -> ([Equation], [[Instr]]))
-> [[Instr]] -> [Equation] -> ([Equation], [[Instr]])
forall a b c. (a -> b -> c) -> b -> a -> c
flip (,) []) Maybe [Equation]
y,Double
z)) Map CId (Type, Int, Maybe [Equation], Double)
funs
                        , cats :: Map CId ([Hypo], [(Double, CId)], Double)
cats=(([Hypo], [(Double, CId)]) -> ([Hypo], [(Double, CId)], Double))
-> Map CId ([Hypo], [(Double, CId)])
-> Map CId ([Hypo], [(Double, CId)], Double)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\([Hypo]
x,[(Double, CId)]
y) -> ([Hypo]
x,[(Double, CId)]
y,Double
0)) Map CId ([Hypo], [(Double, CId)])
cats
                        })
getFun :: Get (Type,Int,Maybe [Equation],Double)
getFun :: Get (Type, Int, Maybe [Equation], Double)
getFun = (,,,) (Type
 -> Int
 -> Maybe [Equation]
 -> Double
 -> (Type, Int, Maybe [Equation], Double))
-> Get Type
-> Get
     (Int
      -> Maybe [Equation]
      -> Double
      -> (Type, Int, Maybe [Equation], Double))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Get Type
getType Get
  (Int
   -> Maybe [Equation]
   -> Double
   -> (Type, Int, Maybe [Equation], Double))
-> Get Int
-> Get
     (Maybe [Equation]
      -> Double -> (Type, Int, Maybe [Equation], Double))
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` Get Int
forall t. Binary t => Get t
get Get
  (Maybe [Equation]
   -> Double -> (Type, Int, Maybe [Equation], Double))
-> Get (Maybe [Equation])
-> Get (Double -> (Type, Int, Maybe [Equation], Double))
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` Get [Equation] -> Get (Maybe [Equation])
forall a. Get a -> Get (Maybe a)
getMaybe (Get Equation -> Get [Equation]
forall a. Get a -> Get [a]
getList Get Equation
getEquation) Get (Double -> (Type, Int, Maybe [Equation], Double))
-> Get Double -> Get (Type, Int, Maybe [Equation], Double)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` Get Double
forall t. Binary t => Get t
get

getCat :: Get ([Hypo],[(Double, CId)])
getCat :: Get ([Hypo], [(Double, CId)])
getCat = Get [Hypo] -> Get [(Double, CId)] -> Get ([Hypo], [(Double, CId)])
forall (m :: * -> *) a a. Monad m => m a -> m a -> m (a, a)
getPair (Get Hypo -> Get [Hypo]
forall a. Get a -> Get [a]
getList Get Hypo
getHypo) (Get (Double, CId) -> Get [(Double, CId)]
forall a. Get a -> Get [a]
getList (Get Double -> Get CId -> Get (Double, CId)
forall (m :: * -> *) a a. Monad m => m a -> m a -> m (a, a)
getPair Get Double
forall t. Binary t => Get t
get Get CId
getCId))

getFlags :: Get (Map CId Literal)
getFlags = Get CId -> Get Literal -> Get (Map CId Literal)
forall k a. Get k -> Get a -> Get (Map k a)
getMap Get CId
getCId Get Literal
getLiteral

getConcr :: Get Concr
getConcr =
        do Map CId Literal
cflags      <- Get (Map CId Literal)
getFlags
           Map CId [Char]
printnames  <- Get CId -> Get [Char] -> Get (Map CId [Char])
forall k a. Get k -> Get a -> Get (Map k a)
getMap Get CId
getCId Get [Char]
forall t. Binary t => Get t
get
           (Int
scnt,[Array Int Symbol]
seqs) <- Get (Array Int Symbol) -> Get (Int, [Array Int Symbol])
forall a. Get a -> Get (Int, [a])
getList' Get (Array Int Symbol)
getSequence
           (Int
fcnt,[CncFun]
cncfuns) <- Get CncFun -> Get (Int, [CncFun])
forall a. Get a -> Get (Int, [a])
getList' Get CncFun
getCncFun
           IntMap [Int]
lindefs     <- Get (IntMap [Int])
forall t. Binary t => Get t
get
           IntMap (Set Production)
productions <- Get (Set Production) -> Get (IntMap (Set Production))
forall a. Get a -> Get (IntMap a)
getIntMap (Get Production -> Get (Set Production)
forall a. Get a -> Get (Set a)
getSet Get Production
getProduction)
           Map CId CncCat
cnccats     <- Get CId -> Get CncCat -> Get (Map CId CncCat)
forall k a. Get k -> Get a -> Get (Map k a)
getMap Get CId
getCId Get CncCat
getCncCat
           Int
totalCats   <- Get Int
forall t. Binary t => Get t
get
           let rseq :: Array Int Symbol
rseq    = [Symbol] -> Array Int Symbol
forall (a :: * -> * -> *) e. IArray a e => [e] -> a Int e
listToArray [Int -> Int -> Symbol
SymCat Int
0 Int
0]
               rfun :: CncFun
rfun    = CId -> UArray Int Int -> CncFun
CncFun ([Char] -> CId
mkCId [Char]
"linref") ([Int] -> UArray Int Int
forall (a :: * -> * -> *) e. IArray a e => [e] -> a Int e
listToArray [Int
scnt])
               linrefs :: IntMap [Int]
linrefs = [(Int, [Int])] -> IntMap [Int]
forall a. [(Int, a)] -> IntMap a
IntMap.fromList [(Int
i,[Int
fcnt])|Int
i<-[Int
0..Int
totalCatsInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1]]
           Concr -> Get Concr
forall (m :: * -> *) a. Monad m => a -> m a
return (Concr :: Map CId Literal
-> Map CId [Char]
-> Array Int CncFun
-> IntMap [Int]
-> IntMap [Int]
-> Array Int (Array Int Symbol)
-> IntMap (Set Production)
-> IntMap (Set Production)
-> Map CId (IntMap (Set Production))
-> Map CId CncCat
-> IntMap (IntMap (TrieMap [Char] IntSet))
-> Int
-> Concr
Concr{ cflags :: Map CId Literal
cflags=Map CId Literal
cflags, printnames :: Map CId [Char]
printnames=Map CId [Char]
printnames
                        , sequences :: Array Int (Array Int Symbol)
sequences=(Int, [Array Int Symbol]) -> Array Int (Array Int Symbol)
forall (a :: * -> * -> *) e. IArray a e => (Int, [e]) -> a Int e
toArray (Int
scntInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1,[Array Int Symbol]
seqs[Array Int Symbol] -> [Array Int Symbol] -> [Array Int Symbol]
forall a. [a] -> [a] -> [a]
++[Array Int Symbol
rseq])
                        , cncfuns :: Array Int CncFun
cncfuns=(Int, [CncFun]) -> Array Int CncFun
forall (a :: * -> * -> *) e. IArray a e => (Int, [e]) -> a Int e
toArray (Int
fcntInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1,[CncFun]
cncfuns[CncFun] -> [CncFun] -> [CncFun]
forall a. [a] -> [a] -> [a]
++[CncFun
rfun])
                        , lindefs :: IntMap [Int]
lindefs=IntMap [Int]
lindefs, linrefs :: IntMap [Int]
linrefs=IntMap [Int]
linrefs
                        , productions :: IntMap (Set Production)
productions=IntMap (Set Production)
productions
                        , pproductions :: IntMap (Set Production)
pproductions = IntMap (Set Production)
forall a. IntMap a
IntMap.empty
                        , lproductions :: Map CId (IntMap (Set Production))
lproductions = Map CId (IntMap (Set Production))
forall k a. Map k a
Map.empty
                        , lexicon :: IntMap (IntMap (TrieMap [Char] IntSet))
lexicon = IntMap (IntMap (TrieMap [Char] IntSet))
forall a. IntMap a
IntMap.empty
                        , cnccats :: Map CId CncCat
cnccats=Map CId CncCat
cnccats, totalCats :: Int
totalCats=Int
totalCats
                        })

getExpr :: Get Expr
getExpr =
        do Word8
tag <- Get Word8
getWord8
           case Word8
tag of
             Word8
0 -> (BindType -> CId -> Expr -> Expr)
-> Get BindType -> Get CId -> Get Expr -> Get Expr
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 BindType -> CId -> Expr -> Expr
EAbs Get BindType
getBindType Get CId
getCId Get Expr
getExpr
             Word8
1 -> (Expr -> Expr -> Expr) -> Get Expr -> Get Expr -> Get Expr
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Expr -> Expr -> Expr
EApp Get Expr
getExpr Get Expr
getExpr
             Word8
2 -> (Literal -> Expr) -> Get Literal -> Get Expr
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  Literal -> Expr
ELit Get Literal
getLiteral
             Word8
3 -> (Int -> Expr) -> Get Int -> Get Expr
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  Int -> Expr
EMeta Get Int
forall t. Binary t => Get t
get
             Word8
4 -> (CId -> Expr) -> Get CId -> Get Expr
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  CId -> Expr
EFun Get CId
getCId
             Word8
5 -> (Int -> Expr) -> Get Int -> Get Expr
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  Int -> Expr
EVar Get Int
forall t. Binary t => Get t
get
             Word8
6 -> (Expr -> Type -> Expr) -> Get Expr -> Get Type -> Get Expr
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Expr -> Type -> Expr
ETyped Get Expr
getExpr Get Type
getType
             Word8
7 -> (Expr -> Expr) -> Get Expr -> Get Expr
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  Expr -> Expr
EImplArg Get Expr
getExpr
             Word8
_ -> [Char] -> Get Expr
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
decodingError [Char]
"getExpr"

getPatt :: Get Patt
getPatt =
        do Word8
tag <- Get Word8
getWord8
           case Word8
tag of
             Word8
0 -> (CId -> [Patt] -> Patt) -> Get CId -> Get [Patt] -> Get Patt
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 CId -> [Patt] -> Patt
PApp Get CId
getCId (Get Patt -> Get [Patt]
forall a. Get a -> Get [a]
getList Get Patt
getPatt)
             Word8
1 -> (CId -> Patt) -> Get CId -> Get Patt
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  CId -> Patt
PVar Get CId
getCId
             Word8
2 -> (CId -> Patt -> Patt) -> Get CId -> Get Patt -> Get Patt
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 CId -> Patt -> Patt
PAs Get CId
getCId Get Patt
getPatt
             Word8
3 -> Patt -> Get Patt
forall (m :: * -> *) a. Monad m => a -> m a
return Patt
PWild
             Word8
4 -> (Literal -> Patt) -> Get Literal -> Get Patt
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  Literal -> Patt
PLit Get Literal
getLiteral
             Word8
5 -> (Patt -> Patt) -> Get Patt -> Get Patt
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  Patt -> Patt
PImplArg Get Patt
getPatt
             Word8
6 -> (Expr -> Patt) -> Get Expr -> Get Patt
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  Expr -> Patt
PTilde Get Expr
getExpr
             Word8
_ -> [Char] -> Get Patt
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
decodingError [Char]
"getPatt"

getEquation :: Get Equation
getEquation = ([Patt] -> Expr -> Equation)
-> Get [Patt] -> Get Expr -> Get Equation
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 [Patt] -> Expr -> Equation
Equ (Get Patt -> Get [Patt]
forall a. Get a -> Get [a]
getList Get Patt
getPatt) Get Expr
getExpr

getType :: Get Type
getType = ([Hypo] -> CId -> [Expr] -> Type)
-> Get [Hypo] -> Get CId -> Get [Expr] -> Get Type
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 [Hypo] -> CId -> [Expr] -> Type
DTyp (Get Hypo -> Get [Hypo]
forall a. Get a -> Get [a]
getList Get Hypo
getHypo) Get CId
getCId (Get Expr -> Get [Expr]
forall a. Get a -> Get [a]
getList Get Expr
getExpr)
getHypo :: Get Hypo
getHypo = (,,) (BindType -> CId -> Type -> Hypo)
-> Get BindType -> Get (CId -> Type -> Hypo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Get BindType
getBindType Get (CId -> Type -> Hypo) -> Get CId -> Get (Type -> Hypo)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` Get CId
getCId Get (Type -> Hypo) -> Get Type -> Get Hypo
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` Get Type
getType

getBindType :: Get BindType
getBindType =
        do Word8
tag <- Get Word8
getWord8
           case Word8
tag of
             Word8
0 -> BindType -> Get BindType
forall (m :: * -> *) a. Monad m => a -> m a
return BindType
Explicit
             Word8
1 -> BindType -> Get BindType
forall (m :: * -> *) a. Monad m => a -> m a
return BindType
Implicit
             Word8
_ -> [Char] -> Get BindType
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
decodingError [Char]
"getBindType"

getCncFun :: Get CncFun
getCncFun = (CId -> UArray Int Int -> CncFun)
-> Get CId -> Get (UArray Int Int) -> Get CncFun
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 CId -> UArray Int Int -> CncFun
CncFun Get CId
getCId (Get Int -> Get (UArray Int Int)
forall (a :: * -> * -> *) e. IArray a e => Get e -> Get (a Int e)
getArray Get Int
forall t. Binary t => Get t
get)

getCncCat :: Get CncCat
getCncCat = (Int -> Int -> Array Int [Char] -> CncCat)
-> Get Int -> Get Int -> Get (Array Int [Char]) -> Get CncCat
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 Int -> Int -> Array Int [Char] -> CncCat
CncCat Get Int
forall t. Binary t => Get t
get Get Int
forall t. Binary t => Get t
get (Get [Char] -> Get (Array Int [Char])
forall (a :: * -> * -> *) e. IArray a e => Get e -> Get (a Int e)
getArray Get [Char]
forall t. Binary t => Get t
get)

getSequence :: Get (Array Int Symbol)
getSequence = [Symbol] -> Array Int Symbol
forall (a :: * -> * -> *) e. IArray a e => [e] -> a Int e
listToArray ([Symbol] -> Array Int Symbol)
-> Get [Symbol] -> Get (Array Int Symbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Get [Symbol]
getSymbols

getSymbols :: Get [Symbol]
getSymbols = [[Symbol]] -> [Symbol]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Symbol]] -> [Symbol]) -> Get [[Symbol]] -> Get [Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Get [Symbol] -> Get [[Symbol]]
forall a. Get a -> Get [a]
getList Get [Symbol]
getSymbol

getSymbol :: Get [Symbol]
getSymbol :: Get [Symbol]
getSymbol =
        do Word8
tag <- Get Word8
getWord8
           case Word8
tag of
             Word8
0 -> (Symbol -> [Symbol] -> [Symbol]
forall a. a -> [a] -> [a]
:[]) (Symbol -> [Symbol]) -> Get Symbol -> Get [Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` (Int -> Int -> Symbol) -> Get Int -> Get Int -> Get Symbol
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Int -> Int -> Symbol
SymCat Get Int
forall t. Binary t => Get t
get Get Int
forall t. Binary t => Get t
get
             Word8
1 -> (Symbol -> [Symbol] -> [Symbol]
forall a. a -> [a] -> [a]
:[]) (Symbol -> [Symbol]) -> Get Symbol -> Get [Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` (Int -> Int -> Symbol) -> Get Int -> Get Int -> Get Symbol
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Int -> Int -> Symbol
SymLit Get Int
forall t. Binary t => Get t
get Get Int
forall t. Binary t => Get t
get
             Word8
2 -> (Symbol -> [Symbol] -> [Symbol]
forall a. a -> [a] -> [a]
:[]) (Symbol -> [Symbol]) -> Get Symbol -> Get [Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` (Int -> Int -> Symbol) -> Get Int -> Get Int -> Get Symbol
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Int -> Int -> Symbol
SymVar Get Int
forall t. Binary t => Get t
get Get Int
forall t. Binary t => Get t
get
             Word8
3 -> ([[Char]] -> [Symbol]) -> Get [[Char]] -> Get [Symbol]
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  (([Char] -> Symbol) -> [[Char]] -> [Symbol]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> Symbol
SymKS) Get [[Char]]
forall t. Binary t => Get t
get
             Word8
4 -> (Symbol -> [Symbol] -> [Symbol]
forall a. a -> [a] -> [a]
:[]) (Symbol -> [Symbol]) -> Get Symbol -> Get [Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` ([Symbol] -> [([Symbol], [[Char]])] -> Symbol)
-> Get [Symbol] -> Get [([Symbol], [[Char]])] -> Get Symbol
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 [Symbol] -> [([Symbol], [[Char]])] -> Symbol
SymKP (Get Symbol -> Get [Symbol]
forall a. Get a -> Get [a]
getList Get Symbol
getTokenSymbol) Get [([Symbol], [[Char]])]
getAlternatives
             Word8
_ -> [Char] -> Get [Symbol]
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
decodingError ([Char]
"getSymbol "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
tag)

getAlternatives :: Get [([Symbol], [[Char]])]
getAlternatives = Get ([Symbol], [[Char]]) -> Get [([Symbol], [[Char]])]
forall a. Get a -> Get [a]
getList (Get [Symbol] -> Get [[Char]] -> Get ([Symbol], [[Char]])
forall (m :: * -> *) a a. Monad m => m a -> m a -> m (a, a)
getPair (Get Symbol -> Get [Symbol]
forall a. Get a -> Get [a]
getList Get Symbol
getTokenSymbol) Get [[Char]]
forall t. Binary t => Get t
get)
                  :: Get [([Symbol],[String])]
getTokenSymbol :: Get Symbol
getTokenSymbol = ([Char] -> Symbol) -> Get [Char] -> Get Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Char] -> Symbol
SymKS Get [Char]
forall t. Binary t => Get t
get

--getTokens = unwords `fmap` get

getPArg :: Get PArg
getPArg = Get ([Int], Int)
forall t. Binary t => Get t
get Get ([Int], Int) -> (([Int], Int) -> Get PArg) -> Get PArg
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Int]
hypos,Int
fid) -> PArg -> Get PArg
forall (m :: * -> *) a. Monad m => a -> m a
return ([(Int, Int)] -> Int -> PArg
PArg ([Int] -> [Int] -> [(Int, Int)]
forall a b. [a] -> [b] -> [(a, b)]
zip (Int -> [Int]
forall a. a -> [a]
repeat Int
fidVar) [Int]
hypos) Int
fid)

getProduction :: Get Production
getProduction =
        do Word8
tag <- Get Word8
getWord8
           case Word8
tag of
             Word8
0 -> (Int -> [PArg] -> Production)
-> Get Int -> Get [PArg] -> Get Production
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Int -> [PArg] -> Production
PApply  Get Int
forall t. Binary t => Get t
get (Get PArg -> Get [PArg]
forall a. Get a -> Get [a]
getList Get PArg
getPArg)
             Word8
1 -> (Int -> Production) -> Get Int -> Get Production
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  Int -> Production
PCoerce Get Int
forall t. Binary t => Get t
get
             Word8
_ -> [Char] -> Get Production
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
decodingError [Char]
"getProduction"

getLiteral :: Get Literal
getLiteral =
        do Word8
tag <- Get Word8
getWord8
           case Word8
tag of
             Word8
0 -> ([Char] -> Literal) -> Get [Char] -> Get Literal
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  [Char] -> Literal
LStr Get [Char]
forall t. Binary t => Get t
get
             Word8
1 -> (Int -> Literal) -> Get Int -> Get Literal
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  Int -> Literal
LInt Get Int
forall t. Binary t => Get t
get
             Word8
2 -> (Double -> Literal) -> Get Double -> Get Literal
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  Double -> Literal
LFlt Get Double
forall t. Binary t => Get t
get
             Word8
_ -> [Char] -> Get Literal
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
decodingError [Char]
"getLiteral"


getArray :: IArray a e => Get e -> Get (a Int e)
getArray :: Get e -> Get (a Int e)
getArray Get e
get1 = (Int, [e]) -> a Int e
forall (a :: * -> * -> *) e. IArray a e => (Int, [e]) -> a Int e
toArray ((Int, [e]) -> a Int e) -> Get (Int, [e]) -> Get (a Int e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Get e -> Get (Int, [e])
forall a. Get a -> Get (Int, [a])
getList' Get e
get1

toArray :: (Int, [e]) -> a Int e
toArray (Int
n,[e]
xs) = (Int, Int) -> [e] -> a Int e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [e] -> a i e
listArray (Int
0::Int,Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) [e]
xs
listToArray :: [e] -> a Int e
listToArray [e]
xs = (Int, [e]) -> a Int e
forall (a :: * -> * -> *) e. IArray a e => (Int, [e]) -> a Int e
toArray ([e] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [e]
xs,[e]
xs)

--getArray2 :: (IArray a1 (a2 Int e), IArray a2 e) => Get e -> Get (a1 Int (a2 Int e))
--getArray2 get1 = getArray (getArray get1)

getList :: Get a -> Get [a]
getList Get a
get1 = (Int, [a]) -> [a]
forall a b. (a, b) -> b
snd ((Int, [a]) -> [a]) -> Get (Int, [a]) -> Get [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Get a -> Get (Int, [a])
forall a. Get a -> Get (Int, [a])
getList' Get a
get1

getList' :: Get a -> Get (Int, [a])
getList' Get a
get1 = do Int
n <- Get Int
forall t. Binary t => Get t
get :: Get Int
                   [a]
xs <- Int -> Get a -> Get [a]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
n Get a
get1
                   (Int, [a]) -> Get (Int, [a])
forall (m :: * -> *) a. Monad m => a -> m a
return (Int
n,[a]
xs)

getMaybe :: Get a -> Get (Maybe a)
getMaybe Get a
get1 =
    do Bool
isJust <- Get Bool
forall t. Binary t => Get t
get
       if Bool
isJust then (a -> Maybe a) -> Get a -> Get (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Maybe a
forall a. a -> Maybe a
Just Get a
get1 else Maybe a -> Get (Maybe a)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing

getMap :: Get k -> Get a -> Get (Map k a)
getMap Get k
getK Get a
getV = [(k, a)] -> Map k a
forall k a. [(k, a)] -> Map k a
Map.fromDistinctAscList ([(k, a)] -> Map k a) -> Get [(k, a)] -> Get (Map k a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Get (k, a) -> Get [(k, a)]
forall a. Get a -> Get [a]
getList (Get k -> Get a -> Get (k, a)
forall (m :: * -> *) a a. Monad m => m a -> m a -> m (a, a)
getPair Get k
getK Get a
getV)
getIntMap :: Get a -> Get (IntMap a)
getIntMap Get a
getV = [(Int, a)] -> IntMap a
forall a. [(Int, a)] -> IntMap a
IntMap.fromDistinctAscList ([(Int, a)] -> IntMap a) -> Get [(Int, a)] -> Get (IntMap a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Get (Int, a) -> Get [(Int, a)]
forall a. Get a -> Get [a]
getList (Get Int -> Get a -> Get (Int, a)
forall (m :: * -> *) a a. Monad m => m a -> m a -> m (a, a)
getPair Get Int
forall t. Binary t => Get t
get Get a
getV)
getSet :: Get a -> Get (Set a)
getSet Get a
getV = [a] -> Set a
forall a. [a] -> Set a
Set.fromDistinctAscList ([a] -> Set a) -> Get [a] -> Get (Set a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Get a -> Get [a]
forall a. Get a -> Get [a]
getList Get a
getV

getPair :: m a -> m a -> m (a, a)
getPair m a
get1 m a
get2 = (,) (a -> a -> (a, a)) -> m a -> m (a -> (a, a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` m a
get1 m (a -> (a, a)) -> m a -> m (a, a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
get2

decodingError :: [Char] -> m a
decodingError [Char]
explain = [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m a) -> [Char] -> m a
forall a b. (a -> b) -> a -> b
$ [Char]
"Unable to read PGF file ("[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
explain[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
")"