module Language.HaLex.Fa2RegExp ( dfa2RegExp
, regExpFromTo
, ndfaregExpFromTo
) where
import Data.List
import Language.HaLex.Util
import Language.HaLex.RegExp
import Language.HaLex.Dfa
import Language.HaLex.Ndfa
regExpFromTo :: Eq st
=> (st -> sy -> st)
-> [sy]
-> st
-> st
-> RegExp sy
regExpFromTo delta v o d = let sys = transitionsFromTo delta v o d
in toRegExp sys
toRegExp :: [sy] -> RegExp sy
toRegExp [] = Empty
toRegExp (x:xs) = toRegExp2 (x:xs)
toRegExp2 [] = Epsilon
toRegExp2 [x] = Literal x
toRegExp2 (x:xs) = Or (Literal x) (toRegExp2 xs)
ndfaregExpFromTo :: Eq st
=> (st -> Maybe sy -> [st])
-> [sy]
-> st
-> st
-> RegExp sy
ndfaregExpFromTo delta v o d = let sys = ndfaTransitionsFromTo delta v o d
in toRegExp' sys
toRegExp' :: [Maybe sy] -> RegExp sy
toRegExp' [] = Empty
toRegExp' (x:xs) = toRegExp2' (x:xs)
toRegExp2' [] = Epsilon
toRegExp2' [x] = case x of
Nothing -> Epsilon
(Just x ) -> Literal x
toRegExp2' (x:xs) = case x of
Nothing -> Or Epsilon (toRegExp2' xs)
(Just x ) -> Or (Literal x) (toRegExp2' xs)
regular :: (Eq st, Num st)
=> (st -> sy -> st)
-> [sy]
-> st
-> st
-> st
-> RegExp sy
regular d v i j 0
| i==j = (regExpFromTo d v i j) `Or` Epsilon
| otherwise = regExpFromTo d v i j
regular d v i j k = Or (Then (Then (regular d v i k (k1))
(Star (regular d v k k (k1)) ) )
(regular d v k j (k1))) (regular d v i j (k1))
dfa2RegExp :: Eq sy
=> Dfa Int sy
-> RegExp sy
dfa2RegExp dfa@(Dfa v q s z delta) =
limit simplifyRegExp (applyD delta v s z (sizeDfa dfa))
applyD :: (Eq st, Num st)
=> (st -> sy -> st)
-> [sy]
-> st
-> [st]
-> st
-> RegExp sy
applyD d v _ [] _ = Epsilon
applyD d v i (z:zs) k = (regular d v i z k) `Or` (applyD d v i zs k)