module PGF.Data (module PGF.Data, module PGF.Expr, module PGF.Type) where
import PGF.CId
import PGF.Expr hiding (Value, Sig, Env, Tree, eval, apply, value2expr)
import PGF.Type
import qualified Data.Map as Map
import qualified Data.Set as Set
import qualified Data.IntMap as IntMap
import Data.Array.IArray
import Data.Array.Unboxed
import Data.List
data PGF = PGF {
gflags :: Map.Map CId Literal,
absname :: CId ,
abstract :: Abstr ,
concretes :: Map.Map CId Concr
}
data Abstr = Abstr {
aflags :: Map.Map CId Literal,
funs :: Map.Map CId (Type,Int,Maybe [Equation]),
cats :: Map.Map CId ([Hypo],[CId])
}
data Concr = Concr {
cflags :: Map.Map CId Literal,
printnames :: Map.Map CId String,
cncfuns :: Array FunId CncFun,
sequences :: Array SeqId Sequence,
productions :: IntMap.IntMap (Set.Set Production),
pproductions :: IntMap.IntMap (Set.Set Production),
lproductions :: Map.Map CId (IntMap.IntMap (Set.Set Production)),
cnccats :: Map.Map CId CncCat,
totalCats :: !FId
}
type FId = Int
type LIndex = Int
type DotPos = Int
data Symbol
= SymCat !Int !LIndex
| SymLit !Int !LIndex
| SymKS [String]
| SymKP [String] [Alternative]
deriving (Eq,Ord,Show)
data Production
= PApply !FunId [FId]
| PCoerce !FId
| PConst Expr [String]
deriving (Eq,Ord,Show)
data CncCat = CncCat !FId !FId !(Array LIndex String)
data CncFun = CncFun CId !(UArray LIndex SeqId) deriving (Eq,Ord,Show)
type Sequence = Array DotPos Symbol
type FunId = Int
type SeqId = Int
data Alternative =
Alt [String] [String]
deriving (Eq,Ord,Show)
data Term =
R [Term]
| P Term Term
| S [Term]
| K Tokn
| V Int
| C Int
| F CId
| FV [Term]
| W String Term
| TM String
deriving (Eq,Ord,Show)
data Tokn =
KS String
| KP [String] [Alternative]
deriving (Eq,Ord,Show)
unionPGF :: PGF -> PGF -> PGF
unionPGF one two = case absname one of
n | n == wildCId -> two
| n == absname two -> one {
concretes = Map.union (concretes two) (concretes one)
}
_ -> one
emptyPGF :: PGF
emptyPGF = PGF {
gflags = Map.empty,
absname = wildCId,
abstract = error "empty grammar, no abstract",
concretes = Map.empty
}
type Language = CId
readLanguage :: String -> Maybe Language
readLanguage = readCId
showLanguage :: Language -> String
showLanguage = showCId
fcatString, fcatInt, fcatFloat, fcatVar :: Int
fcatString = (1)
fcatInt = (2)
fcatFloat = (3)
fcatVar = (4)
isLiteralFCat :: FId -> Bool
isLiteralFCat = (`elem` [fcatString, fcatInt, fcatFloat, fcatVar])