{-# LINE 1 "Data/Yaml/Syck.hsc" #-}
{-# LANGUAGE ForeignFunctionInterface, MagicHash, CPP, DeriveDataTypeable, TypeSynonymInstances, PatternGuards, RecursiveDo #-}



module Data.Yaml.Syck (
    parseYaml, emitYaml,
    parseYamlFile, emitYamlFile,
    parseYamlBytes, emitYamlBytes,
    YamlNode(..), YamlElem(..), YamlAnchor(..),
    tagNode, nilNode, mkNode, mkTagNode, mkTagStrNode, SYMID,
    packBuf, unpackBuf,
) where

import Control.Exception (bracket)
import Data.IORef
import Data.Maybe (fromJust)
import Data.Generics
import Foreign.Ptr
import Foreign.StablePtr
import Foreign.C.Types
import Foreign.C.String
import Foreign.Marshal.Alloc
import Foreign.Marshal.Utils
import Foreign.Storable
import System.IO.Unsafe
import GHC.Ptr (Ptr(..))
import qualified Data.HashTable.IO as Hash
import qualified Data.ByteString.Char8 as Buf
import Data.ByteString.UTF8 (fromString, toString)
import Data.ByteString.Char8 (useAsCStringLen, useAsCString)
import Data.ByteString (packCString, packCStringLen)

type Buf        = Buf.ByteString
type YamlTag    = Maybe Buf
data YamlAnchor
    = AAnchor    !Int
    | AReference !Int
    | ASingleton
    deriving (Int -> YamlAnchor -> ShowS
[YamlAnchor] -> ShowS
YamlAnchor -> String
(Int -> YamlAnchor -> ShowS)
-> (YamlAnchor -> String)
-> ([YamlAnchor] -> ShowS)
-> Show YamlAnchor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> YamlAnchor -> ShowS
showsPrec :: Int -> YamlAnchor -> ShowS
$cshow :: YamlAnchor -> String
show :: YamlAnchor -> String
$cshowList :: [YamlAnchor] -> ShowS
showList :: [YamlAnchor] -> ShowS
Show, Eq YamlAnchor
Eq YamlAnchor =>
(YamlAnchor -> YamlAnchor -> Ordering)
-> (YamlAnchor -> YamlAnchor -> Bool)
-> (YamlAnchor -> YamlAnchor -> Bool)
-> (YamlAnchor -> YamlAnchor -> Bool)
-> (YamlAnchor -> YamlAnchor -> Bool)
-> (YamlAnchor -> YamlAnchor -> YamlAnchor)
-> (YamlAnchor -> YamlAnchor -> YamlAnchor)
-> Ord YamlAnchor
YamlAnchor -> YamlAnchor -> Bool
YamlAnchor -> YamlAnchor -> Ordering
YamlAnchor -> YamlAnchor -> YamlAnchor
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: YamlAnchor -> YamlAnchor -> Ordering
compare :: YamlAnchor -> YamlAnchor -> Ordering
$c< :: YamlAnchor -> YamlAnchor -> Bool
< :: YamlAnchor -> YamlAnchor -> Bool
$c<= :: YamlAnchor -> YamlAnchor -> Bool
<= :: YamlAnchor -> YamlAnchor -> Bool
$c> :: YamlAnchor -> YamlAnchor -> Bool
> :: YamlAnchor -> YamlAnchor -> Bool
$c>= :: YamlAnchor -> YamlAnchor -> Bool
>= :: YamlAnchor -> YamlAnchor -> Bool
$cmax :: YamlAnchor -> YamlAnchor -> YamlAnchor
max :: YamlAnchor -> YamlAnchor -> YamlAnchor
$cmin :: YamlAnchor -> YamlAnchor -> YamlAnchor
min :: YamlAnchor -> YamlAnchor -> YamlAnchor
Ord, YamlAnchor -> YamlAnchor -> Bool
(YamlAnchor -> YamlAnchor -> Bool)
-> (YamlAnchor -> YamlAnchor -> Bool) -> Eq YamlAnchor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: YamlAnchor -> YamlAnchor -> Bool
== :: YamlAnchor -> YamlAnchor -> Bool
$c/= :: YamlAnchor -> YamlAnchor -> Bool
/= :: YamlAnchor -> YamlAnchor -> Bool
Eq, Typeable, Typeable YamlAnchor
Typeable YamlAnchor =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> YamlAnchor -> c YamlAnchor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c YamlAnchor)
-> (YamlAnchor -> Constr)
-> (YamlAnchor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c YamlAnchor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c YamlAnchor))
-> ((forall b. Data b => b -> b) -> YamlAnchor -> YamlAnchor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> YamlAnchor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> YamlAnchor -> r)
-> (forall u. (forall d. Data d => d -> u) -> YamlAnchor -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> YamlAnchor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> YamlAnchor -> m YamlAnchor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> YamlAnchor -> m YamlAnchor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> YamlAnchor -> m YamlAnchor)
-> Data YamlAnchor
YamlAnchor -> Constr
YamlAnchor -> DataType
(forall b. Data b => b -> b) -> YamlAnchor -> YamlAnchor
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> YamlAnchor -> u
forall u. (forall d. Data d => d -> u) -> YamlAnchor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> YamlAnchor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> YamlAnchor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> YamlAnchor -> m YamlAnchor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlAnchor -> m YamlAnchor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c YamlAnchor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> YamlAnchor -> c YamlAnchor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c YamlAnchor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c YamlAnchor)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> YamlAnchor -> c YamlAnchor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> YamlAnchor -> c YamlAnchor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c YamlAnchor
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c YamlAnchor
$ctoConstr :: YamlAnchor -> Constr
toConstr :: YamlAnchor -> Constr
$cdataTypeOf :: YamlAnchor -> DataType
dataTypeOf :: YamlAnchor -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c YamlAnchor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c YamlAnchor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c YamlAnchor)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c YamlAnchor)
$cgmapT :: (forall b. Data b => b -> b) -> YamlAnchor -> YamlAnchor
gmapT :: (forall b. Data b => b -> b) -> YamlAnchor -> YamlAnchor
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> YamlAnchor -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> YamlAnchor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> YamlAnchor -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> YamlAnchor -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> YamlAnchor -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> YamlAnchor -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> YamlAnchor -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> YamlAnchor -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> YamlAnchor -> m YamlAnchor
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> YamlAnchor -> m YamlAnchor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlAnchor -> m YamlAnchor
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlAnchor -> m YamlAnchor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlAnchor -> m YamlAnchor
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlAnchor -> m YamlAnchor
Data)

type SYMID = CULong

instance Data SYMID where

{-# LINE 45 "Data/Yaml/Syck.hsc" #-}
  toConstr x = mkIntegralConstr (mkIntType "Foreign.C.Types.CULong") (fromIntegral x)

{-# LINE 49 "Data/Yaml/Syck.hsc" #-}
  gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SYMID
gunfold forall b r. Data b => c (b -> r) -> c r
_ forall r. r -> c r
z Constr
c = case Constr -> ConstrRep
constrRep Constr
c of
                    (IntConstr Integer
x) -> SYMID -> c SYMID
forall r. r -> c r
z (Integer -> SYMID
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
x)
                    ConstrRep
_ -> String -> c SYMID
forall a. HasCallStack => String -> a
error String
"gunfold"
  dataTypeOf :: SYMID -> DataType
dataTypeOf SYMID
_ = String -> DataType
mkIntType String
"Foreign.C.Types.CULong"

data YamlNode = MkNode
    { YamlNode -> SYMID
n_id        :: !SYMID
    , YamlNode -> YamlElem
n_elem      :: !YamlElem
    , YamlNode -> Maybe Buf
n_tag       :: !YamlTag
    , YamlNode -> YamlAnchor
n_anchor    :: !YamlAnchor
    }
    deriving (Int -> YamlNode -> ShowS
[YamlNode] -> ShowS
YamlNode -> String
(Int -> YamlNode -> ShowS)
-> (YamlNode -> String) -> ([YamlNode] -> ShowS) -> Show YamlNode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> YamlNode -> ShowS
showsPrec :: Int -> YamlNode -> ShowS
$cshow :: YamlNode -> String
show :: YamlNode -> String
$cshowList :: [YamlNode] -> ShowS
showList :: [YamlNode] -> ShowS
Show, Eq YamlNode
Eq YamlNode =>
(YamlNode -> YamlNode -> Ordering)
-> (YamlNode -> YamlNode -> Bool)
-> (YamlNode -> YamlNode -> Bool)
-> (YamlNode -> YamlNode -> Bool)
-> (YamlNode -> YamlNode -> Bool)
-> (YamlNode -> YamlNode -> YamlNode)
-> (YamlNode -> YamlNode -> YamlNode)
-> Ord YamlNode
YamlNode -> YamlNode -> Bool
YamlNode -> YamlNode -> Ordering
YamlNode -> YamlNode -> YamlNode
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: YamlNode -> YamlNode -> Ordering
compare :: YamlNode -> YamlNode -> Ordering
$c< :: YamlNode -> YamlNode -> Bool
< :: YamlNode -> YamlNode -> Bool
$c<= :: YamlNode -> YamlNode -> Bool
<= :: YamlNode -> YamlNode -> Bool
$c> :: YamlNode -> YamlNode -> Bool
> :: YamlNode -> YamlNode -> Bool
$c>= :: YamlNode -> YamlNode -> Bool
>= :: YamlNode -> YamlNode -> Bool
$cmax :: YamlNode -> YamlNode -> YamlNode
max :: YamlNode -> YamlNode -> YamlNode
$cmin :: YamlNode -> YamlNode -> YamlNode
min :: YamlNode -> YamlNode -> YamlNode
Ord, YamlNode -> YamlNode -> Bool
(YamlNode -> YamlNode -> Bool)
-> (YamlNode -> YamlNode -> Bool) -> Eq YamlNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: YamlNode -> YamlNode -> Bool
== :: YamlNode -> YamlNode -> Bool
$c/= :: YamlNode -> YamlNode -> Bool
/= :: YamlNode -> YamlNode -> Bool
Eq, Typeable, Typeable YamlNode
Typeable YamlNode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> YamlNode -> c YamlNode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c YamlNode)
-> (YamlNode -> Constr)
-> (YamlNode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c YamlNode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c YamlNode))
-> ((forall b. Data b => b -> b) -> YamlNode -> YamlNode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> YamlNode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> YamlNode -> r)
-> (forall u. (forall d. Data d => d -> u) -> YamlNode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> YamlNode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> YamlNode -> m YamlNode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> YamlNode -> m YamlNode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> YamlNode -> m YamlNode)
-> Data YamlNode
YamlNode -> Constr
YamlNode -> DataType
(forall b. Data b => b -> b) -> YamlNode -> YamlNode
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> YamlNode -> u
forall u. (forall d. Data d => d -> u) -> YamlNode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> YamlNode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> YamlNode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> YamlNode -> m YamlNode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlNode -> m YamlNode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c YamlNode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> YamlNode -> c YamlNode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c YamlNode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c YamlNode)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> YamlNode -> c YamlNode
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> YamlNode -> c YamlNode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c YamlNode
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c YamlNode
$ctoConstr :: YamlNode -> Constr
toConstr :: YamlNode -> Constr
$cdataTypeOf :: YamlNode -> DataType
dataTypeOf :: YamlNode -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c YamlNode)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c YamlNode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c YamlNode)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c YamlNode)
$cgmapT :: (forall b. Data b => b -> b) -> YamlNode -> YamlNode
gmapT :: (forall b. Data b => b -> b) -> YamlNode -> YamlNode
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> YamlNode -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> YamlNode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> YamlNode -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> YamlNode -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> YamlNode -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> YamlNode -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> YamlNode -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> YamlNode -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> YamlNode -> m YamlNode
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> YamlNode -> m YamlNode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlNode -> m YamlNode
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlNode -> m YamlNode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlNode -> m YamlNode
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlNode -> m YamlNode
Data)

data YamlElem
    = EMap [(YamlNode, YamlNode)]
    | ESeq [YamlNode]
    | EStr !Buf
    | ENil
    deriving (Int -> YamlElem -> ShowS
[YamlElem] -> ShowS
YamlElem -> String
(Int -> YamlElem -> ShowS)
-> (YamlElem -> String) -> ([YamlElem] -> ShowS) -> Show YamlElem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> YamlElem -> ShowS
showsPrec :: Int -> YamlElem -> ShowS
$cshow :: YamlElem -> String
show :: YamlElem -> String
$cshowList :: [YamlElem] -> ShowS
showList :: [YamlElem] -> ShowS
Show, Eq YamlElem
Eq YamlElem =>
(YamlElem -> YamlElem -> Ordering)
-> (YamlElem -> YamlElem -> Bool)
-> (YamlElem -> YamlElem -> Bool)
-> (YamlElem -> YamlElem -> Bool)
-> (YamlElem -> YamlElem -> Bool)
-> (YamlElem -> YamlElem -> YamlElem)
-> (YamlElem -> YamlElem -> YamlElem)
-> Ord YamlElem
YamlElem -> YamlElem -> Bool
YamlElem -> YamlElem -> Ordering
YamlElem -> YamlElem -> YamlElem
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: YamlElem -> YamlElem -> Ordering
compare :: YamlElem -> YamlElem -> Ordering
$c< :: YamlElem -> YamlElem -> Bool
< :: YamlElem -> YamlElem -> Bool
$c<= :: YamlElem -> YamlElem -> Bool
<= :: YamlElem -> YamlElem -> Bool
$c> :: YamlElem -> YamlElem -> Bool
> :: YamlElem -> YamlElem -> Bool
$c>= :: YamlElem -> YamlElem -> Bool
>= :: YamlElem -> YamlElem -> Bool
$cmax :: YamlElem -> YamlElem -> YamlElem
max :: YamlElem -> YamlElem -> YamlElem
$cmin :: YamlElem -> YamlElem -> YamlElem
min :: YamlElem -> YamlElem -> YamlElem
Ord, YamlElem -> YamlElem -> Bool
(YamlElem -> YamlElem -> Bool)
-> (YamlElem -> YamlElem -> Bool) -> Eq YamlElem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: YamlElem -> YamlElem -> Bool
== :: YamlElem -> YamlElem -> Bool
$c/= :: YamlElem -> YamlElem -> Bool
/= :: YamlElem -> YamlElem -> Bool
Eq, Typeable, Typeable YamlElem
Typeable YamlElem =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> YamlElem -> c YamlElem)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c YamlElem)
-> (YamlElem -> Constr)
-> (YamlElem -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c YamlElem))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c YamlElem))
-> ((forall b. Data b => b -> b) -> YamlElem -> YamlElem)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> YamlElem -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> YamlElem -> r)
-> (forall u. (forall d. Data d => d -> u) -> YamlElem -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> YamlElem -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> YamlElem -> m YamlElem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> YamlElem -> m YamlElem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> YamlElem -> m YamlElem)
-> Data YamlElem
YamlElem -> Constr
YamlElem -> DataType
(forall b. Data b => b -> b) -> YamlElem -> YamlElem
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> YamlElem -> u
forall u. (forall d. Data d => d -> u) -> YamlElem -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> YamlElem -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> YamlElem -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> YamlElem -> m YamlElem
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlElem -> m YamlElem
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c YamlElem
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> YamlElem -> c YamlElem
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c YamlElem)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c YamlElem)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> YamlElem -> c YamlElem
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> YamlElem -> c YamlElem
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c YamlElem
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c YamlElem
$ctoConstr :: YamlElem -> Constr
toConstr :: YamlElem -> Constr
$cdataTypeOf :: YamlElem -> DataType
dataTypeOf :: YamlElem -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c YamlElem)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c YamlElem)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c YamlElem)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c YamlElem)
$cgmapT :: (forall b. Data b => b -> b) -> YamlElem -> YamlElem
gmapT :: (forall b. Data b => b -> b) -> YamlElem -> YamlElem
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> YamlElem -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> YamlElem -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> YamlElem -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> YamlElem -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> YamlElem -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> YamlElem -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> YamlElem -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> YamlElem -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> YamlElem -> m YamlElem
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> YamlElem -> m YamlElem
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlElem -> m YamlElem
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlElem -> m YamlElem
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlElem -> m YamlElem
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> YamlElem -> m YamlElem
Data)

type SyckNode = Ptr ()
type SyckParser = Ptr ()
type SyckNodeHandler = SyckParser -> SyckNode -> IO SYMID
type SyckErrorHandler = SyckParser -> CString -> IO ()
type SyckBadAnchorHandler = SyckParser -> CString -> IO SyckNodePtr
type SyckNodePtr = Ptr CString
type SyckEmitter = Ptr ()
type SyckEmitterHandler = SyckEmitter -> Ptr () -> IO ()
type SyckOutputHandler = SyckEmitter -> CString -> CLong -> IO ()
data SyckKind = SyckMap | SyckSeq | SyckStr
    deriving (Int -> SyckKind -> ShowS
[SyckKind] -> ShowS
SyckKind -> String
(Int -> SyckKind -> ShowS)
-> (SyckKind -> String) -> ([SyckKind] -> ShowS) -> Show SyckKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SyckKind -> ShowS
showsPrec :: Int -> SyckKind -> ShowS
$cshow :: SyckKind -> String
show :: SyckKind -> String
$cshowList :: [SyckKind] -> ShowS
showList :: [SyckKind] -> ShowS
Show, Eq SyckKind
Eq SyckKind =>
(SyckKind -> SyckKind -> Ordering)
-> (SyckKind -> SyckKind -> Bool)
-> (SyckKind -> SyckKind -> Bool)
-> (SyckKind -> SyckKind -> Bool)
-> (SyckKind -> SyckKind -> Bool)
-> (SyckKind -> SyckKind -> SyckKind)
-> (SyckKind -> SyckKind -> SyckKind)
-> Ord SyckKind
SyckKind -> SyckKind -> Bool
SyckKind -> SyckKind -> Ordering
SyckKind -> SyckKind -> SyckKind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SyckKind -> SyckKind -> Ordering
compare :: SyckKind -> SyckKind -> Ordering
$c< :: SyckKind -> SyckKind -> Bool
< :: SyckKind -> SyckKind -> Bool
$c<= :: SyckKind -> SyckKind -> Bool
<= :: SyckKind -> SyckKind -> Bool
$c> :: SyckKind -> SyckKind -> Bool
> :: SyckKind -> SyckKind -> Bool
$c>= :: SyckKind -> SyckKind -> Bool
>= :: SyckKind -> SyckKind -> Bool
$cmax :: SyckKind -> SyckKind -> SyckKind
max :: SyckKind -> SyckKind -> SyckKind
$cmin :: SyckKind -> SyckKind -> SyckKind
min :: SyckKind -> SyckKind -> SyckKind
Ord, SyckKind -> SyckKind -> Bool
(SyckKind -> SyckKind -> Bool)
-> (SyckKind -> SyckKind -> Bool) -> Eq SyckKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SyckKind -> SyckKind -> Bool
== :: SyckKind -> SyckKind -> Bool
$c/= :: SyckKind -> SyckKind -> Bool
/= :: SyckKind -> SyckKind -> Bool
Eq, Int -> SyckKind
SyckKind -> Int
SyckKind -> [SyckKind]
SyckKind -> SyckKind
SyckKind -> SyckKind -> [SyckKind]
SyckKind -> SyckKind -> SyckKind -> [SyckKind]
(SyckKind -> SyckKind)
-> (SyckKind -> SyckKind)
-> (Int -> SyckKind)
-> (SyckKind -> Int)
-> (SyckKind -> [SyckKind])
-> (SyckKind -> SyckKind -> [SyckKind])
-> (SyckKind -> SyckKind -> [SyckKind])
-> (SyckKind -> SyckKind -> SyckKind -> [SyckKind])
-> Enum SyckKind
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SyckKind -> SyckKind
succ :: SyckKind -> SyckKind
$cpred :: SyckKind -> SyckKind
pred :: SyckKind -> SyckKind
$ctoEnum :: Int -> SyckKind
toEnum :: Int -> SyckKind
$cfromEnum :: SyckKind -> Int
fromEnum :: SyckKind -> Int
$cenumFrom :: SyckKind -> [SyckKind]
enumFrom :: SyckKind -> [SyckKind]
$cenumFromThen :: SyckKind -> SyckKind -> [SyckKind]
enumFromThen :: SyckKind -> SyckKind -> [SyckKind]
$cenumFromTo :: SyckKind -> SyckKind -> [SyckKind]
enumFromTo :: SyckKind -> SyckKind -> [SyckKind]
$cenumFromThenTo :: SyckKind -> SyckKind -> SyckKind -> [SyckKind]
enumFromThenTo :: SyckKind -> SyckKind -> SyckKind -> [SyckKind]
Enum)

maxId :: SYMID
maxId :: SYMID
maxId = SYMID
forall a. Bounded a => a
maxBound

nilNode :: YamlNode
nilNode :: YamlNode
nilNode = SYMID -> YamlElem -> Maybe Buf -> YamlAnchor -> YamlNode
MkNode SYMID
maxId YamlElem
ENil Maybe Buf
forall a. Maybe a
Nothing YamlAnchor
ASingleton

-- | Convert a ByteString buffer into a regular Haskell string

{-# INLINE unpackBuf #-}
unpackBuf :: Buf -> String
unpackBuf :: Buf -> String
unpackBuf = Buf -> String
Buf.unpack

-- | Convert a regular Haskell string into a ByteString buffer

{-# INLINE packBuf #-}
packBuf :: String -> Buf
packBuf :: String -> Buf
packBuf = String -> Buf
Buf.pack

tagNode :: YamlTag -> YamlNode -> YamlNode
tagNode :: Maybe Buf -> YamlNode -> YamlNode
tagNode Maybe Buf
_ MkNode{n_tag :: YamlNode -> Maybe Buf
n_tag=Just Buf
x} = String -> YamlNode
forall a. HasCallStack => String -> a
error (String -> YamlNode) -> String -> YamlNode
forall a b. (a -> b) -> a -> b
$ String
"can't add tag: already tagged with" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Buf -> String
unpackBuf Buf
x
tagNode Maybe Buf
tag YamlNode
node               = YamlNode
node{n_tag = tag}

mkNode :: YamlElem -> YamlNode
mkNode :: YamlElem -> YamlNode
mkNode YamlElem
x = SYMID -> YamlElem -> Maybe Buf -> YamlAnchor -> YamlNode
MkNode SYMID
maxId YamlElem
x Maybe Buf
forall a. Maybe a
Nothing YamlAnchor
ASingleton

mkTagNode :: String -> YamlElem -> YamlNode
mkTagNode :: String -> YamlElem -> YamlNode
mkTagNode String
tag YamlElem
e = SYMID -> YamlElem -> Maybe Buf -> YamlAnchor -> YamlNode
MkNode SYMID
maxId YamlElem
e (Buf -> Maybe Buf
forall a. a -> Maybe a
Just (Buf -> Maybe Buf) -> Buf -> Maybe Buf
forall a b. (a -> b) -> a -> b
$! String -> Buf
packBuf String
tag) YamlAnchor
ASingleton

mkTagStrNode :: String -> String -> YamlNode
mkTagStrNode :: String -> String -> YamlNode
mkTagStrNode String
tag String
str = String -> YamlElem -> YamlNode
mkTagNode String
tag (Buf -> YamlElem
EStr (Buf -> YamlElem) -> Buf -> YamlElem
forall a b. (a -> b) -> a -> b
$! String -> Buf
packBuf String
str)

-- the extra commas here are not a bug
scalarNone :: CInt
scalarNone :: CInt
scalarNone =  CInt
0
CInt
scalar1quote :: CInt
CInt
scalar1quote =  CInt
1
scalar2quote :: CInt
scalar2quote :: CInt
scalar2quote CInt
=  CInt
2
scalarFold :: CInt
scalarFold :: CInt
scalarFold =  3
scalarLiteral :: CInt
scalarLiteral =  4
scalarPlain :: CInt
scalarPlain =  5

{-# LINE 114 "Data/Yaml/Syck.hsc" #-}
seqNone :: CInt
seqNone =  0
seqInline :: CInt
seqInline =  1

{-# LINE 115 "Data/Yaml/Syck.hsc" #-}
mapNone :: CInt
mapNone =  0
mapInline :: CInt
mapInline =  1

{-# LINE 116 "Data/Yaml/Syck.hsc" #-}

-- | Dump a YAML node into a ByteString buffer (fast)

emitYamlBytes :: YamlNode -> IO Buf
emitYamlBytes node = do
    bracket syck_new_emitter syck_free_emitter $ \emitter -> do
        -- set up output port
        out    <- newIORef []
        (\hsc_ptr -> pokeByteOff hsc_ptr 32) emitter scalarFold
{-# LINE 125 "Data/Yaml/Syck.hsc" #-}
        (\hsc_ptr -> pokeByteOff hsc_ptr 16) emitter (Ptr "%d"# :: CString)
{-# LINE 126 "Data/Yaml/Syck.hsc" #-}

        marks <- Hash.new

        let freeze = freezeNode marks
        syck_emitter_handler emitter =<< mkEmitterCallback (emitterCallback freeze)
        syck_output_handler emitter =<< mkOutputCallback (outputCallbackPS out)

        markYamlNode freeze emitter node

        nodePtr <- freeze node
        let nodePtr' = fromIntegral $ nodePtr `minusPtr` nullPtr
        syck_emit emitter nodePtr'
        syck_emitter_flush emitter 0
        fmap (Buf.concat . reverse) (readIORef out)

-- | Given a file name, dump a YAML node into that file

emitYamlFile :: FilePath -> YamlNode -> IO ()
emitYamlFile :: String -> YamlNode -> IO ()
emitYamlFile String
file YamlNode
node = do
    Buf
buf <- YamlNode -> IO Buf
emitYamlBytes YamlNode
node
    String -> Buf -> IO ()
Buf.writeFile String
file Buf
buf

-- | Dump a YAML node into a regular Haskell string

emitYaml :: YamlNode -> IO String
emitYaml :: YamlNode -> IO String
emitYaml YamlNode
node = (Buf -> String) -> IO Buf -> IO String
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Buf -> String
toString (YamlNode -> IO Buf
emitYamlBytes YamlNode
node)

markYamlNode :: (YamlNode -> IO SyckNodePtr) -> SyckEmitter -> YamlNode -> IO ()
{-
markYamlNode marks emitter MkNode{ anchor = AReference n } = do
    Just nodePtr <- Hash.lookup marks n
    syck_emitter_mark_node emitter nodePtr
    return ()
-}
markYamlNode :: (YamlNode -> IO SyckNodePtr) -> Ptr () -> YamlNode -> IO ()
markYamlNode YamlNode -> IO SyckNodePtr
freeze Ptr ()
emitter YamlNode
node = do
    SyckNodePtr
nodePtr <- YamlNode -> IO SyckNodePtr
freeze YamlNode
node
    SYMID
rv      <- Ptr () -> SyckNodePtr -> IO SYMID
syck_emitter_mark_node Ptr ()
emitter SyckNodePtr
nodePtr
    if SYMID
rv SYMID -> SYMID -> Bool
forall a. Eq a => a -> a -> Bool
== SYMID
0 then () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return () else do
        case YamlNode -> YamlElem
n_elem YamlNode
node of
            EMap [(YamlNode, YamlNode)]
xs  -> [IO ()] -> IO ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [ YamlNode -> IO ()
mark YamlNode
x IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> YamlNode -> IO ()
mark YamlNode
y | (YamlNode
x, YamlNode
y) <- [(YamlNode, YamlNode)]
xs ]
            ESeq [YamlNode]
xs  -> (YamlNode -> IO ()) -> [YamlNode] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ YamlNode -> IO ()
mark [YamlNode]
xs
            YamlElem
_        -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    where
    mark :: YamlNode -> IO ()
mark = (YamlNode -> IO SyckNodePtr) -> Ptr () -> YamlNode -> IO ()
markYamlNode YamlNode -> IO SyckNodePtr
freeze Ptr ()
emitter

outputCallbackPS :: IORef [Buf] -> SyckEmitter -> CString -> CLong -> IO ()
outputCallbackPS :: IORef [Buf] -> SyckOutputHandler
outputCallbackPS IORef [Buf]
out Ptr ()
emitter CString
buf CLong
len = do
    Buf
str <- CStringLen -> IO Buf
packCStringLen (CString
buf, CLong -> Int
forall a. Enum a => a -> Int
fromEnum CLong
len)
    Buf
str Buf -> IO () -> IO ()
forall a b. a -> b -> b
`seq` IORef [Buf] -> ([Buf] -> [Buf]) -> IO ()
forall a. IORef a -> (a -> a) -> IO ()
modifyIORef IORef [Buf]
out (Buf
strBuf -> [Buf] -> [Buf]
forall a. a -> [a] -> [a]
:)

outputCallback :: SyckEmitter -> CString -> CLong -> IO ()
outputCallback :: SyckOutputHandler
outputCallback Ptr ()
emitter CString
buf CLong
len = do
    Ptr ()
outPtr  <- (\Ptr ()
hsc_ptr -> Ptr () -> Int -> IO (Ptr ())
forall b. Ptr b -> Int -> IO (Ptr ())
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr ()
hsc_ptr Int
144) Ptr ()
emitter
{-# LINE 179 "Data/Yaml/Syck.hsc" #-}
    out     <- deRefStablePtr (castPtrToStablePtr outPtr)
    String
str     <- CStringLen -> IO String
peekCStringLen (CString
buf, CLong -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral CLong
len)
    IORef String -> ShowS -> IO ()
forall a. IORef a -> (a -> a) -> IO ()
modifyIORef IORef String
out (String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
str)

emitterCallback :: (YamlNode -> IO SyckNodePtr) -> SyckEmitter -> Ptr () -> IO ()
emitterCallback :: (YamlNode -> IO SyckNodePtr) -> SyckEmitterHandler
emitterCallback YamlNode -> IO SyckNodePtr
f Ptr ()
e Ptr ()
vp = (YamlNode -> IO SyckNodePtr) -> Ptr () -> YamlNode -> IO ()
emitNode YamlNode -> IO SyckNodePtr
f Ptr ()
e (YamlNode -> IO ()) -> IO YamlNode -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr () -> IO YamlNode
thawNode Ptr ()
vp

emitNode :: (YamlNode -> IO SyckNodePtr) -> SyckEmitter -> YamlNode -> IO ()
emitNode :: (YamlNode -> IO SyckNodePtr) -> Ptr () -> YamlNode -> IO ()
emitNode YamlNode -> IO SyckNodePtr
_ Ptr ()
e YamlNode
n | YamlNode -> YamlElem
n_elem YamlNode
n YamlElem -> YamlElem -> Bool
forall a. Eq a => a -> a -> Bool
== YamlElem
ENil = do
    YamlNode -> CString -> (CString -> IO ()) -> IO ()
forall a. YamlNode -> CString -> (CString -> IO a) -> IO a
withTag YamlNode
n (Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"string"#) ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \CString
tag ->
        Ptr ()
-> CString
-> CInt
-> CInt
-> CInt
-> CInt
-> CString
-> CInt
-> IO ()
syck_emit_scalar Ptr ()
e CString
tag CInt
scalarNone CInt
0 CInt
0 CInt
0 (Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"~"#) CInt
1

emitNode YamlNode -> IO SyckNodePtr
_ Ptr ()
e YamlNode
n | EStr Buf
s <- YamlNode -> YamlElem
n_elem YamlNode
n, Buf -> Int
Buf.length Buf
s Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1, Buf -> Char
Buf.head Buf
s Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'~' = do
    YamlNode -> CString -> (CString -> IO ()) -> IO ()
forall a. YamlNode -> CString -> (CString -> IO a) -> IO a
withTag YamlNode
n (Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"string"#) ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \CString
tag ->
        Ptr ()
-> CString
-> CInt
-> CInt
-> CInt
-> CInt
-> CString
-> CInt
-> IO ()
syck_emit_scalar Ptr ()
e CString
tag CInt
scalar1quote CInt
0 CInt
0 CInt
0 (Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"~"#) CInt
1

emitNode YamlNode -> IO SyckNodePtr
_ Ptr ()
e YamlNode
n | EStr Buf
s <- YamlNode -> YamlElem
n_elem YamlNode
n = do
    YamlNode -> CString -> (CString -> IO ()) -> IO ()
forall a. YamlNode -> CString -> (CString -> IO a) -> IO a
withTag YamlNode
n (Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"string"#) ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \CString
tag ->
        Buf -> (CStringLen -> IO ()) -> IO ()
forall a. Buf -> (CStringLen -> IO a) -> IO a
useAsCStringLen Buf
s ((CStringLen -> IO ()) -> IO ()) -> (CStringLen -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \(CString
cs, Int
l) ->
        Ptr ()
-> CString
-> CInt
-> CInt
-> CInt
-> CInt
-> CString
-> CInt
-> IO ()
syck_emit_scalar Ptr ()
e CString
tag CInt
scalarFold CInt
0 CInt
0 CInt
0 CString
cs (Int -> CInt
forall a. Enum a => Int -> a
toEnum Int
l)

emitNode YamlNode -> IO SyckNodePtr
freeze Ptr ()
e YamlNode
n | ESeq [YamlNode]
sq <- YamlNode -> YamlElem
n_elem YamlNode
n = do
    YamlNode -> CString -> (CString -> IO ()) -> IO ()
forall a. YamlNode -> CString -> (CString -> IO a) -> IO a
withTag YamlNode
n (Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"array"#) ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \CString
tag ->
--        syck_emit_seq e tag seqInline
      Ptr () -> CString -> CInt -> IO ()
syck_emit_seq Ptr ()
e CString
tag CInt
seqNone
    (SyckNodePtr -> IO ()) -> [SyckNodePtr] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (Ptr () -> SyckNodePtr -> IO ()
syck_emit_item Ptr ()
e) ([SyckNodePtr] -> IO ()) -> IO [SyckNodePtr] -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (YamlNode -> IO SyckNodePtr) -> [YamlNode] -> IO [SyckNodePtr]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM YamlNode -> IO SyckNodePtr
freeze [YamlNode]
sq
    Ptr () -> IO ()
syck_emit_end Ptr ()
e

emitNode YamlNode -> IO SyckNodePtr
freeze Ptr ()
e YamlNode
n | EMap [(YamlNode, YamlNode)]
m <- YamlNode -> YamlElem
n_elem YamlNode
n = do
    YamlNode -> CString -> (CString -> IO ()) -> IO ()
forall a. YamlNode -> CString -> (CString -> IO a) -> IO a
withTag YamlNode
n (Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"map"#) ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \CString
tag ->
--        syck_emit_map e tag mapInline
      Ptr () -> CString -> CInt -> IO ()
syck_emit_map Ptr ()
e CString
tag CInt
mapNone
    (((YamlNode, YamlNode) -> IO ())
 -> [(YamlNode, YamlNode)] -> IO ())
-> [(YamlNode, YamlNode)]
-> ((YamlNode, YamlNode) -> IO ())
-> IO ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((YamlNode, YamlNode) -> IO ()) -> [(YamlNode, YamlNode)] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ [(YamlNode, YamlNode)]
m (\(YamlNode
k,YamlNode
v) -> do
        Ptr () -> SyckNodePtr -> IO ()
syck_emit_item Ptr ()
e (SyckNodePtr -> IO ()) -> IO SyckNodePtr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< YamlNode -> IO SyckNodePtr
freeze YamlNode
k
        Ptr () -> SyckNodePtr -> IO ()
syck_emit_item Ptr ()
e (SyckNodePtr -> IO ()) -> IO SyckNodePtr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< YamlNode -> IO SyckNodePtr
freeze YamlNode
v)
    Ptr () -> IO ()
syck_emit_end Ptr ()
e

withTag :: YamlNode -> CString -> (CString -> IO a) -> IO a
withTag :: forall a. YamlNode -> CString -> (CString -> IO a) -> IO a
withTag YamlNode
node CString
def CString -> IO a
f = IO a -> (Buf -> IO a) -> Maybe Buf -> IO a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (CString -> IO a
f CString
def) (Buf -> (CString -> IO a) -> IO a
forall a. Buf -> (CString -> IO a) -> IO a
`useAsCString` CString -> IO a
f) (YamlNode -> Maybe Buf
n_tag YamlNode
node)

-- | Parse a regular Haskell string

parseYaml :: String -> IO YamlNode
parseYaml :: String -> IO YamlNode
parseYaml = Buf -> IO YamlNode
parseYamlBytes (Buf -> IO YamlNode) -> (String -> Buf) -> String -> IO YamlNode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Buf
fromString

-- | Given a file name, parse contents of file

parseYamlFile :: String -> IO YamlNode
parseYamlFile :: String -> IO YamlNode
parseYamlFile String
file = Buf -> IO YamlNode
parseYamlBytes (Buf -> IO YamlNode) -> IO Buf -> IO YamlNode
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< String -> IO Buf
Buf.readFile String
file

-- | Parse a ByteString buffer (this is faster)

parseYamlBytes :: Buf -> IO YamlNode
parseYamlBytes :: Buf -> IO YamlNode
parseYamlBytes = (Buf -> (CString -> IO YamlNode) -> IO YamlNode
forall a. Buf -> (CString -> IO a) -> IO a
`useAsCString` CString -> IO YamlNode
parseYamlCStr)

parseYamlCStr :: CString -> IO YamlNode
parseYamlCStr :: CString -> IO YamlNode
parseYamlCStr CString
cstr = do
    IO (Ptr ())
-> (Ptr () -> IO ()) -> (Ptr () -> IO YamlNode) -> IO YamlNode
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket IO (Ptr ())
syck_new_parser Ptr () -> IO ()
syck_free_parser ((Ptr () -> IO YamlNode) -> IO YamlNode)
-> (Ptr () -> IO YamlNode) -> IO YamlNode
forall a b. (a -> b) -> a -> b
$ \Ptr ()
parser -> do
        IORef (Maybe String)
err     <- Maybe String -> IO (IORef (Maybe String))
forall a. a -> IO (IORef a)
newIORef Maybe String
forall a. Maybe a
Nothing
        HashTable RealWorld Int YamlNode
badancs <- IO (HashTable RealWorld Int YamlNode)
IO (IOHashTable HashTable Int YamlNode)
forall (h :: * -> * -> * -> *) k v.
HashTable h =>
IO (IOHashTable h k v)
Hash.new
        Ptr () -> CString -> FunPtr () -> IO ()
syck_parser_str_auto Ptr ()
parser CString
cstr FunPtr ()
forall a. FunPtr a
nullFunPtr
        Ptr () -> FunPtr SyckNodeHandler -> IO ()
syck_parser_handler Ptr ()
parser (FunPtr SyckNodeHandler -> IO ())
-> IO (FunPtr SyckNodeHandler) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< SyckNodeHandler -> IO (FunPtr SyckNodeHandler)
mkNodeCallback (IOHashTable HashTable Int YamlNode -> SyckNodeHandler
nodeCallback HashTable RealWorld Int YamlNode
IOHashTable HashTable Int YamlNode
badancs)
        Ptr () -> FunPtr (Ptr () -> CString -> IO ()) -> IO ()
syck_parser_error_handler Ptr ()
parser (FunPtr (Ptr () -> CString -> IO ()) -> IO ())
-> IO (FunPtr (Ptr () -> CString -> IO ())) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (Ptr () -> CString -> IO ())
-> IO (FunPtr (Ptr () -> CString -> IO ()))
mkErrorCallback (IORef (Maybe String) -> Ptr () -> CString -> IO ()
errorCallback IORef (Maybe String)
err)
        Ptr () -> FunPtr SyckBadAnchorHandler -> IO ()
syck_parser_bad_anchor_handler Ptr ()
parser (FunPtr SyckBadAnchorHandler -> IO ())
-> IO (FunPtr SyckBadAnchorHandler) -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< SyckBadAnchorHandler -> IO (FunPtr SyckBadAnchorHandler)
mkBadHandlerCallback (IOHashTable HashTable Int YamlNode -> SyckBadAnchorHandler
badAnchorHandlerCallback HashTable RealWorld Int YamlNode
IOHashTable HashTable Int YamlNode
badancs)
        Ptr () -> CInt -> IO ()
syck_parser_implicit_typing Ptr ()
parser CInt
0
        Ptr () -> CInt -> IO ()
syck_parser_taguri_expansion Ptr ()
parser CInt
0
        SYMID
symId <- Ptr () -> IO SYMID
syck_parse Ptr ()
parser
        if SYMID
symId SYMID -> SYMID -> Bool
forall a. Eq a => a -> a -> Bool
/= SYMID
0 then Ptr () -> SYMID -> IO YamlNode
readNode Ptr ()
parser SYMID
symId else do
            Maybe String
rv <- IORef (Maybe String) -> IO (Maybe String)
forall a. IORef a -> IO a
readIORef IORef (Maybe String)
err
            case Maybe String
rv of
                Maybe String
Nothing     -> YamlNode -> IO YamlNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return YamlNode
nilNode
                Just String
e      -> String -> IO YamlNode
forall a. String -> IO a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
e

type HashTable k v = Hash.CuckooHashTable k v
type BadAnchorTable = HashTable Int YamlNode


nodeCallback :: BadAnchorTable -> SyckParser -> SyckNode -> IO SYMID
nodeCallback :: IOHashTable HashTable Int YamlNode -> SyckNodeHandler
nodeCallback IOHashTable HashTable Int YamlNode
badancs Ptr ()
parser Ptr ()
syckNode = mdo
    SYMID
nodeId  <- (\Ptr ()
hsc_ptr -> Ptr () -> Int -> IO SYMID
forall b. Ptr b -> Int -> IO SYMID
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr ()
hsc_ptr Int
0) Ptr ()
syckNode
{-# LINE 259 "Data/Yaml/Syck.hsc" #-}
    kind    <- syckNodeKind syckNode

    let makeRegularNode :: IO YamlNode
makeRegularNode = do
            CLong
len     <- SyckKind -> Ptr () -> IO CLong
syckNodeLength SyckKind
kind Ptr ()
syckNode
            SyckKind -> Ptr () -> Ptr () -> CLong -> SYMID -> IO YamlNode
parseNode SyckKind
kind Ptr ()
parser Ptr ()
syckNode CLong
len SYMID
symId

    YamlNode
node    <- case SyckKind
kind of
        SyckKind
SyckMap -> do
            Maybe YamlNode
rv  <- IOHashTable HashTable Int YamlNode -> Int -> IO (Maybe YamlNode)
forall (h :: * -> * -> * -> *) k v.
(HashTable h, Eq k, Hashable k) =>
IOHashTable h k v -> k -> IO (Maybe v)
Hash.lookup IOHashTable HashTable Int YamlNode
badancs (Ptr ()
syckNode Ptr () -> Ptr Any -> Int
forall a b. Ptr a -> Ptr b -> Int
`minusPtr` Ptr Any
forall a. Ptr a
nullPtr)
            case Maybe YamlNode
rv of
                Just{}  -> do
                    -- print ("bad anchor wanted", syckNode)
                    IO YamlNode -> IO YamlNode
forall a. IO a -> IO a
unsafeInterleaveIO ((Maybe YamlNode -> YamlNode) -> IO (Maybe YamlNode) -> IO YamlNode
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe YamlNode -> YamlNode
forall a. HasCallStack => Maybe a -> a
fromJust (IOHashTable HashTable Int YamlNode -> Int -> IO (Maybe YamlNode)
forall (h :: * -> * -> * -> *) k v.
(HashTable h, Eq k, Hashable k) =>
IOHashTable h k v -> k -> IO (Maybe v)
Hash.lookup IOHashTable HashTable Int YamlNode
badancs (SyckNodePtr
nodePtr SyckNodePtr -> Ptr Any -> Int
forall a b. Ptr a -> Ptr b -> Int
`minusPtr` Ptr Any
forall a. Ptr a
nullPtr)))
                Maybe YamlNode
_       -> IO YamlNode
makeRegularNode
        SyckKind
_       -> IO YamlNode
makeRegularNode
    SyckNodePtr
nodePtr <- YamlNode -> IO SyckNodePtr
writeNode YamlNode
node

    -- Do something here about circular refs.
    case SYMID
nodeId :: SYMID of
        SYMID
0   -> Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
        SYMID
_   -> do
            (Ptr SyckNodePtr -> IO ()) -> IO ()
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr SyckNodePtr -> IO ()) -> IO ())
-> (Ptr SyckNodePtr -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SyckNodePtr
origPtr -> do
                Ptr () -> SYMID -> Ptr SyckNodePtr -> IO CInt
syck_lookup_sym Ptr ()
parser SYMID
nodeId Ptr SyckNodePtr
origPtr
                SyckNodePtr
ptr <- Ptr SyckNodePtr -> IO SyckNodePtr
forall a. Storable a => Ptr a -> IO a
peek Ptr SyckNodePtr
origPtr
                -- print ("bad anchor handled", nodeId, ptr)
                IOHashTable HashTable Int YamlNode -> Int -> YamlNode -> IO ()
forall (h :: * -> * -> * -> *) k v.
(HashTable h, Eq k, Hashable k) =>
IOHashTable h k v -> k -> v -> IO ()
Hash.insert IOHashTable HashTable Int YamlNode
badancs (SyckNodePtr
ptr SyckNodePtr -> Ptr Any -> Int
forall a b. Ptr a -> Ptr b -> Int
`minusPtr` Ptr Any
forall a. Ptr a
nullPtr) YamlNode
node
            Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True

    SYMID
symId   <- (CInt -> SYMID) -> IO CInt -> IO SYMID
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CInt -> SYMID
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Ptr () -> SyckNodePtr -> IO CInt
syck_add_sym Ptr ()
parser SyckNodePtr
nodePtr)
    SYMID -> IO SYMID
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SYMID
symId

badAnchorHandlerCallback :: BadAnchorTable -> SyckBadAnchorHandler
badAnchorHandlerCallback :: IOHashTable HashTable Int YamlNode -> SyckBadAnchorHandler
badAnchorHandlerCallback IOHashTable HashTable Int YamlNode
badancs Ptr ()
parser CString
cstr = do
    SyckNodePtr
syckNode    <- IO SyckNodePtr
syck_alloc_map
    -- msg         <- peekCString cstr
    -- print ("bad anchor encountered", syckNode)
    IOHashTable HashTable Int YamlNode -> Int -> YamlNode -> IO ()
forall (h :: * -> * -> * -> *) k v.
(HashTable h, Eq k, Hashable k) =>
IOHashTable h k v -> k -> v -> IO ()
Hash.insert IOHashTable HashTable Int YamlNode
badancs (SyckNodePtr
syckNode SyckNodePtr -> Ptr Any -> Int
forall a b. Ptr a -> Ptr b -> Int
`minusPtr` Ptr Any
forall a. Ptr a
nullPtr) (String -> YamlNode
forall a. HasCallStack => String -> a
error String
"unhandled bad anchor")
    SyckNodePtr -> IO SyckNodePtr
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SyckNodePtr
syckNode

errorCallback :: IORef (Maybe String) -> SyckErrorHandler
errorCallback :: IORef (Maybe String) -> Ptr () -> CString -> IO ()
errorCallback IORef (Maybe String)
err Ptr ()
parser CString
cstr = do
    String
msg     <- CString -> IO String
peekCString CString
cstr
    CChar
lineptr <- (\Ptr ()
hsc_ptr -> Ptr () -> Int -> IO CChar
forall b. Ptr b -> Int -> IO CChar
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr ()
hsc_ptr Int
80) Ptr ()
parser :: IO CChar
{-# LINE 302 "Data/Yaml/Syck.hsc" #-}
    cursor  <- (\hsc_ptr -> peekByteOff hsc_ptr 104) parser  :: IO CChar
{-# LINE 303 "Data/Yaml/Syck.hsc" #-}
    linect  <- (\hsc_ptr -> peekByteOff hsc_ptr 128) parser  :: IO CChar
{-# LINE 304 "Data/Yaml/Syck.hsc" #-}
    writeIORef err . Just $ concat
        [ msg
        , ": line ", show (1 + fromEnum linect)
        , ", column ", show (cursor - lineptr)
        ]

freezeNode :: HashTable Int (Ptr a) -> YamlNode -> IO (Ptr a)
freezeNode :: forall a. HashTable Int (Ptr a) -> YamlNode -> IO (Ptr a)
freezeNode HashTable Int (Ptr a)
nodes MkNode{ n_anchor :: YamlNode -> YamlAnchor
n_anchor = AReference Int
n } = do
    Maybe (Ptr a)
rv <- HashTable Int (Ptr a) -> Int -> IO (Maybe (Ptr a))
forall (h :: * -> * -> * -> *) k v.
(HashTable h, Eq k, Hashable k) =>
IOHashTable h k v -> k -> IO (Maybe v)
Hash.lookup HashTable Int (Ptr a)
nodes Int
n
    case Maybe (Ptr a)
rv of
        Just Ptr a
ptr    -> Ptr a -> IO (Ptr a)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr a
ptr
        Maybe (Ptr a)
_           -> String -> IO (Ptr a)
forall a. String -> IO a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> IO (Ptr a)) -> String -> IO (Ptr a)
forall a b. (a -> b) -> a -> b
$ String
"Failed to resolve reference: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n
freezeNode HashTable Int (Ptr a)
nodes YamlNode
node = do
    StablePtr YamlNode
ptr     <- YamlNode -> IO (StablePtr YamlNode)
forall a. a -> IO (StablePtr a)
newStablePtr YamlNode
node
    case YamlNode -> YamlAnchor
n_anchor YamlNode
node of
        AAnchor Int
n -> do
            Maybe (Ptr a)
rv <- HashTable Int (Ptr a) -> Int -> IO (Maybe (Ptr a))
forall (h :: * -> * -> * -> *) k v.
(HashTable h, Eq k, Hashable k) =>
IOHashTable h k v -> k -> IO (Maybe v)
Hash.lookup HashTable Int (Ptr a)
nodes Int
n
            case Maybe (Ptr a)
rv of
                Just Ptr a
ptr -> Ptr a -> IO (Ptr a)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr a
ptr
                Maybe (Ptr a)
_ -> do
                    StablePtr YamlNode
ptr     <- YamlNode -> IO (StablePtr YamlNode)
forall a. a -> IO (StablePtr a)
newStablePtr YamlNode
node
                    let ptr' :: Ptr b
ptr' = Ptr () -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr (StablePtr YamlNode -> Ptr ()
forall a. StablePtr a -> Ptr ()
castStablePtrToPtr StablePtr YamlNode
ptr)
                    HashTable Int (Ptr a) -> Int -> Ptr a -> IO ()
forall (h :: * -> * -> * -> *) k v.
(HashTable h, Eq k, Hashable k) =>
IOHashTable h k v -> k -> v -> IO ()
Hash.insert HashTable Int (Ptr a)
nodes Int
n Ptr a
forall a. Ptr a
ptr'
                    Ptr a -> IO (Ptr a)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr a -> IO (Ptr a)) -> Ptr a -> IO (Ptr a)
forall a b. (a -> b) -> a -> b
$! Ptr a
forall a. Ptr a
ptr'
        YamlAnchor
_         -> do
            StablePtr YamlNode
ptr     <- YamlNode -> IO (StablePtr YamlNode)
forall a. a -> IO (StablePtr a)
newStablePtr YamlNode
node
            Ptr a -> IO (Ptr a)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr a -> IO (Ptr a)) -> Ptr a -> IO (Ptr a)
forall a b. (a -> b) -> a -> b
$! Ptr () -> Ptr a
forall a b. Ptr a -> Ptr b
castPtr (StablePtr YamlNode -> Ptr ()
forall a. StablePtr a -> Ptr ()
castStablePtrToPtr StablePtr YamlNode
ptr)

thawNode :: Ptr () -> IO YamlNode
thawNode :: Ptr () -> IO YamlNode
thawNode Ptr ()
nodePtr = StablePtr YamlNode -> IO YamlNode
forall a. StablePtr a -> IO a
deRefStablePtr (Ptr () -> StablePtr YamlNode
forall a. Ptr () -> StablePtr a
castPtrToStablePtr Ptr ()
nodePtr)

writeNode :: YamlNode -> IO SyckNodePtr
writeNode :: YamlNode -> IO SyckNodePtr
writeNode YamlNode
node = do
    StablePtr YamlNode
ptr <- YamlNode -> IO (StablePtr YamlNode)
forall a. a -> IO (StablePtr a)
newStablePtr YamlNode
node
    CString -> IO SyckNodePtr
forall a. Storable a => a -> IO (Ptr a)
new (Ptr () -> CString
forall a b. Ptr a -> Ptr b
castPtr (Ptr () -> CString) -> Ptr () -> CString
forall a b. (a -> b) -> a -> b
$ StablePtr YamlNode -> Ptr ()
forall a. StablePtr a -> Ptr ()
castStablePtrToPtr StablePtr YamlNode
ptr)

readNode :: SyckParser -> SYMID -> IO YamlNode
readNode :: Ptr () -> SYMID -> IO YamlNode
readNode Ptr ()
parser SYMID
symId = (Ptr SyckNodePtr -> IO YamlNode) -> IO YamlNode
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr SyckNodePtr -> IO YamlNode) -> IO YamlNode)
-> (Ptr SyckNodePtr -> IO YamlNode) -> IO YamlNode
forall a b. (a -> b) -> a -> b
$ \Ptr SyckNodePtr
nodePtr -> do
    Ptr () -> SYMID -> Ptr SyckNodePtr -> IO CInt
syck_lookup_sym Ptr ()
parser SYMID
symId Ptr SyckNodePtr
nodePtr
    Ptr ()
ptr <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek (Ptr (Ptr ()) -> IO (Ptr ()))
-> (SyckNodePtr -> Ptr (Ptr ())) -> SyckNodePtr -> IO (Ptr ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SyckNodePtr -> Ptr (Ptr ())
forall a b. Ptr a -> Ptr b
castPtr (SyckNodePtr -> IO (Ptr ())) -> IO SyckNodePtr -> IO (Ptr ())
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr SyckNodePtr -> IO SyckNodePtr
forall a. Storable a => Ptr a -> IO a
peek Ptr SyckNodePtr
nodePtr
    StablePtr YamlNode -> IO YamlNode
forall a. StablePtr a -> IO a
deRefStablePtr (Ptr () -> StablePtr YamlNode
forall a. Ptr () -> StablePtr a
castPtrToStablePtr Ptr ()
ptr)

{-# NOINLINE _tagLiteral #-}
{-# NOINLINE _colonLiteral #-}
_tagLiteral, _colonLiteral :: Buf
_tagLiteral :: Buf
_tagLiteral   = String -> Buf
packBuf String
"tag:"
_colonLiteral :: Buf
_colonLiteral = String -> Buf
packBuf String
":"

syckNodeTag :: SyckNode -> IO (Maybe Buf)
syckNodeTag :: Ptr () -> IO (Maybe Buf)
syckNodeTag Ptr ()
syckNode = do
    CString
tag <- (\Ptr ()
hsc_ptr -> Ptr () -> Int -> IO CString
forall b. Ptr b -> Int -> IO CString
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr ()
hsc_ptr Int
16) Ptr ()
syckNode
{-# LINE 355 "Data/Yaml/Syck.hsc" #-}
    if (tag == nullPtr) then (return Nothing) else do
        p <- packCString tag
        return $! case Buf.elemIndex '/' p of
            Just n -> let { pre = Buf.take n p; post = Buf.drop (n+1) p } in
                Just $ Buf.concat [_tagLiteral, pre, _colonLiteral, post]
            Nothing -> Nothing

syckNodeKind :: SyckNode -> IO SyckKind
syckNodeKind :: Ptr () -> IO SyckKind
syckNodeKind Ptr ()
syckNode = do
    Int
kind <- (\Ptr ()
hsc_ptr -> Ptr () -> Int -> IO Int
forall b. Ptr b -> Int -> IO Int
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr ()
hsc_ptr Int
8) Ptr ()
syckNode
{-# LINE 365 "Data/Yaml/Syck.hsc" #-}
    return $ toEnum (kind `mod` 4)

syckNodeLength :: SyckKind -> SyckNode -> IO CLong
syckNodeLength :: SyckKind -> Ptr () -> IO CLong
syckNodeLength SyckKind
SyckMap = ((\Ptr Any
hsc_ptr -> Ptr Any -> Int -> IO CLong
forall b. Ptr b -> Int -> IO CLong
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr Any
hsc_ptr Int
32) (Ptr Any -> IO CLong) -> IO (Ptr Any) -> IO CLong
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (IO (Ptr Any) -> IO CLong)
-> (Ptr () -> IO (Ptr Any)) -> Ptr () -> IO CLong
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Ptr ()
hsc_ptr -> Ptr () -> Int -> IO (Ptr Any)
forall b. Ptr b -> Int -> IO (Ptr Any)
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr ()
hsc_ptr Int
32)
{-# LINE 369 "Data/Yaml/Syck.hsc" #-}
syckNodeLength SyckSeq = ((\hsc_ptr -> peekByteOff hsc_ptr 24) =<<) . (\hsc_ptr -> peekByteOff hsc_ptr 32)
{-# LINE 370 "Data/Yaml/Syck.hsc" #-}
syckNodeLength SyckStr = ((\hsc_ptr -> peekByteOff hsc_ptr 16) =<<) . (\hsc_ptr -> peekByteOff hsc_ptr 32)
{-# LINE 371 "Data/Yaml/Syck.hsc" #-}

parseNode :: SyckKind -> SyckParser -> SyckNode -> CLong -> SYMID -> IO YamlNode
parseNode :: SyckKind -> Ptr () -> Ptr () -> CLong -> SYMID -> IO YamlNode
parseNode SyckKind
SyckMap Ptr ()
parser Ptr ()
syckNode CLong
len SYMID
nid = do
    Maybe Buf
tag   <- Ptr () -> IO (Maybe Buf)
syckNodeTag Ptr ()
syckNode
    [(YamlNode, YamlNode)]
pairs <- ((CLong -> IO (YamlNode, YamlNode))
-> [CLong] -> IO [(YamlNode, YamlNode)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
`mapM` [CLong
0..CLong
lenCLong -> CLong -> CLong
forall a. Num a => a -> a -> a
-CLong
1]) ((CLong -> IO (YamlNode, YamlNode)) -> IO [(YamlNode, YamlNode)])
-> (CLong -> IO (YamlNode, YamlNode)) -> IO [(YamlNode, YamlNode)]
forall a b. (a -> b) -> a -> b
$ \CLong
idx -> do
        SYMID
keyId   <- Ptr () -> CInt -> CLong -> IO SYMID
syck_map_read Ptr ()
syckNode CInt
0 CLong
idx
        YamlNode
key     <- Ptr () -> SYMID -> IO YamlNode
readNode Ptr ()
parser SYMID
keyId
        SYMID
valId   <- Ptr () -> CInt -> CLong -> IO SYMID
syck_map_read Ptr ()
syckNode CInt
1 CLong
idx
        YamlNode
val     <- Ptr () -> SYMID -> IO YamlNode
readNode Ptr ()
parser SYMID
valId
        (YamlNode, YamlNode) -> IO (YamlNode, YamlNode)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (YamlNode
key, YamlNode
val)
    YamlNode -> IO YamlNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (YamlNode -> IO YamlNode) -> YamlNode -> IO YamlNode
forall a b. (a -> b) -> a -> b
$ YamlNode
nilNode{ n_elem = EMap pairs, n_tag = tag, n_id = nid }

parseNode SyckKind
SyckSeq Ptr ()
parser Ptr ()
syckNode CLong
len SYMID
nid = do
    Maybe Buf
tag   <- Ptr () -> IO (Maybe Buf)
syckNodeTag Ptr ()
syckNode
    [YamlNode]
nodes <- ((CLong -> IO YamlNode) -> [CLong] -> IO [YamlNode]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
`mapM` [CLong
0..CLong
lenCLong -> CLong -> CLong
forall a. Num a => a -> a -> a
-CLong
1]) ((CLong -> IO YamlNode) -> IO [YamlNode])
-> (CLong -> IO YamlNode) -> IO [YamlNode]
forall a b. (a -> b) -> a -> b
$ \CLong
idx -> do
        SYMID
symId   <- Ptr () -> CLong -> IO SYMID
syck_seq_read Ptr ()
syckNode CLong
idx
        Ptr () -> SYMID -> IO YamlNode
readNode Ptr ()
parser SYMID
symId
    YamlNode -> IO YamlNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (YamlNode -> IO YamlNode) -> YamlNode -> IO YamlNode
forall a b. (a -> b) -> a -> b
$ YamlNode
nilNode{ n_elem = ESeq nodes, n_tag = tag, n_id = nid }

parseNode SyckKind
SyckStr Ptr ()
_ Ptr ()
syckNode CLong
len SYMID
nid = do
    Maybe Buf
tag   <- Ptr () -> IO (Maybe Buf)
syckNodeTag Ptr ()
syckNode
    CString
cstr  <- Ptr () -> IO CString
syck_str_read Ptr ()
syckNode
    Buf
buf   <- CStringLen -> IO Buf
packCStringLen (CString
cstr, CLong -> Int
forall a. Enum a => a -> Int
fromEnum CLong
len)
    let node :: YamlNode
node = YamlNode
nilNode{ n_elem = EStr buf, n_tag = tag, n_id = nid }
    if Maybe Buf
tag Maybe Buf -> Maybe Buf -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Buf
forall a. Maybe a
Nothing Bool -> Bool -> Bool
&& Buf -> Int
Buf.length Buf
buf Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 Bool -> Bool -> Bool
&& Buf -> Int -> Char
Buf.index Buf
buf Int
0 Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'~'
        then do
            CInt
style <- Ptr () -> IO CInt
syck_str_style Ptr ()
syckNode
            if CInt
style CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
== CInt
scalarPlain
                then YamlNode -> IO YamlNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return YamlNode
nilNode
                else YamlNode -> IO YamlNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return YamlNode
node
        else YamlNode -> IO YamlNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return YamlNode
node

foreign import ccall "wrapper"
    mkNodeCallback :: SyckNodeHandler -> IO (FunPtr SyckNodeHandler)

foreign import ccall "wrapper"
    mkErrorCallback :: SyckErrorHandler -> IO (FunPtr SyckErrorHandler)

foreign import ccall "wrapper"
    mkBadHandlerCallback :: SyckBadAnchorHandler -> IO (FunPtr SyckBadAnchorHandler)

foreign import ccall "wrapper"
    mkOutputCallback :: SyckOutputHandler -> IO (FunPtr SyckOutputHandler)

foreign import ccall "wrapper"
    mkEmitterCallback :: SyckEmitterHandler -> IO (FunPtr SyckEmitterHandler)

foreign import ccall
    syck_new_parser :: IO SyckParser

foreign import ccall
    syck_alloc_map :: IO SyckNodePtr

foreign import ccall
    syck_parser_str_auto :: SyckParser -> CString -> FunPtr () -> IO ()

foreign import ccall
    syck_parser_error_handler :: SyckParser -> FunPtr SyckErrorHandler -> IO ()

foreign import ccall
    syck_parser_bad_anchor_handler :: SyckParser -> FunPtr SyckBadAnchorHandler -> IO ()

foreign import ccall
    syck_parser_implicit_typing :: SyckParser -> CInt -> IO ()

foreign import ccall
    syck_parser_taguri_expansion :: SyckParser -> CInt -> IO ()

foreign import ccall
    syck_parser_handler :: SyckParser -> FunPtr SyckNodeHandler -> IO ()

foreign import ccall
    syck_add_sym :: SyckParser -> SyckNodePtr -> IO CInt

foreign import ccall
    syck_parse :: SyckParser -> IO SYMID

foreign import ccall
    syck_free_parser :: SyckParser -> IO ()

foreign import ccall
    syck_lookup_sym :: SyckParser -> SYMID -> Ptr SyckNodePtr -> IO CInt

foreign import ccall
    syck_str_read :: SyckNode -> IO CString

foreign import ccall
    syck_str_style :: SyckNode -> IO CInt

foreign import ccall
    syck_seq_read :: SyckNode -> CLong -> IO SYMID

foreign import ccall
    syck_map_read :: SyckNode -> CInt -> CLong -> IO SYMID

foreign import ccall
    syck_new_emitter :: IO SyckEmitter

foreign import ccall
    syck_free_emitter :: SyckEmitter -> IO ()

foreign import ccall
    syck_emitter_handler :: SyckEmitter -> FunPtr SyckEmitterHandler -> IO ()

foreign import ccall
    syck_output_handler :: SyckEmitter -> FunPtr SyckOutputHandler -> IO ()

foreign import ccall
    syck_emit :: SyckEmitter -> CLong -> IO ()

foreign import ccall
    syck_emitter_flush :: SyckEmitter -> CLong -> IO ()

foreign import ccall
    syck_emitter_mark_node :: SyckEmitter -> SyckNodePtr -> IO SYMID

foreign import ccall
    syck_emit_scalar :: SyckEmitter -> CString -> CInt -> CInt -> CInt -> CInt -> CString -> CInt -> IO ()

foreign import ccall
    syck_emit_seq :: SyckEmitter -> CString -> CInt -> IO ()

foreign import ccall
    syck_emit_item :: SyckEmitter -> SyckNodePtr -> IO ()

foreign import ccall
    syck_emit_end :: SyckEmitter -> IO ()

foreign import ccall
    syck_emit_map :: SyckEmitter -> CString -> CInt -> IO ()

-- vim: syntax=haskell :