Changeset 15829 for third-party

Show
Ignore:
Timestamp:
04/04/07 19:54:22 (20 months ago)
Author:
audreyt
Message:

* Revert r15828 as promised.

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • third-party/HsSyck/Data/Yaml/Syck.hsc

    r15828 r15829  
    7171    deriving (Show, Ord, Eq, Enum) 
    7272 
    73 maxId :: SYMID 
    74 maxId = maxBound 
    75  
    7673nilNode :: YamlNode 
    77 nilNode = MkNode maxId ENil Nothing ASingleton 
     74nilNode = MkNode 0 ENil Nothing ASingleton 
    7875 
    7976{-# INLINE unpackBuf #-} 
    … …  
    9087 
    9188mkNode :: YamlElem -> YamlNode 
    92 mkNode x = MkNode maxId x Nothing ASingleton 
     89mkNode x = MkNode 0 x Nothing ASingleton 
    9390 
    9491mkTagNode :: String -> YamlElem -> YamlNode 
    95 mkTagNode tag e = MkNode maxId e (Just $! packBuf tag) ASingleton 
     92mkTagNode tag e = MkNode 0 e (Just $! packBuf tag) ASingleton 
    9693 
    9794mkTagStrNode :: String -> String -> YamlNode 
    … …  
    189186    withTag n (Ptr "array"##) $ \tag -> 
    190187        syck_emit_seq e tag seqInline 
    191 --      syck_emit_seq e tag seqNone 
    192188    mapM_ (syck_emit_item e) =<< mapM freeze sq 
    193189    syck_emit_end e 
    … …  
    196192    withTag n (Ptr "map"##) $ \tag -> 
    197193        syck_emit_map e tag mapInline 
    198 --      syck_emit_map e tag mapNone 
    199194    flip mapM_ m (\(k,v) -> do 
    200195        syck_emit_item e =<< freeze k 
    … …  
    237232nodeCallback :: BadAnchorTable -> SyckParser -> SyckNode -> IO SYMID 
    238233nodeCallback badancs parser syckNode = mdo 
    239     nodeId  <- #{peek SyckNode, id} syckNode 
    240234    kind    <- syckNodeKind syckNode 
    241  
    242     let makeRegularNode = do 
    243         len     <- syckNodeLength kind syckNode 
    244         parseNode kind parser syckNode len symId 
    245  
    246235    node    <- case kind of 
    247236        SyckMap -> do 
    … …  
    251240                    -- print ("bad anchor wanted", syckNode) 
    252241                    unsafeInterleaveIO (fmap fromJust (Hash.lookup badancs (nodePtr `minusPtr` nullPtr))) 
    253                 _       -> makeRegularNode 
    254         _       -> makeRegularNode 
     242                _       -> makeRegularNode kind 
     243        _       -> makeRegularNode kind 
    255244    nodePtr <- writeNode node 
    256245 
    257246    -- Do something here about circular refs. 
     247    nodeId  <- #{peek SyckNode, id} syckNode 
    258248    case nodeId :: SYMID of 
    259249        0   -> return False 
    … …  
    264254            Hash.update badancs (ptr `minusPtr` nullPtr) node 
    265255 
    266     symId   <- fmap fromIntegral (syck_add_sym parser nodePtr) 
    267  
    268     return symId 
     256    symId   <- syck_add_sym parser nodePtr 
     257    return (fromIntegral symId) 
     258    where 
     259    makeRegularNode kind = do 
     260        len     <- syckNodeLength kind syckNode 
     261        parseNode kind parser syckNode len 
    269262 
    270263badAnchorHandlerCallback :: BadAnchorTable -> SyckBadAnchorHandler 
    … …  
    290283freezeNode :: Hash.HashTable Int (Ptr a) -> YamlNode -> IO (Ptr a) 
    291284freezeNode nodes MkNode{ n_anchor = AReference n } = do 
    292     rv <- Hash.lookup nodes n 
    293     case rv of 
    294         Just ptr    -> return ptr 
    295         _           -> fail $ "Failed to resolve reference: " ++ show n 
     285    Just ptr <- Hash.lookup nodes n 
     286    return ptr 
    296287freezeNode nodes node = do 
    297288    ptr     <- newStablePtr node 
    … …  
    350341syckNodeLength SyckStr = (#{peek struct SyckStr, len} =<<) . #{peek SyckNode, data} 
    351342 
    352 parseNode :: SyckKind -> SyckParser -> SyckNode -> CLong -> SYMID -> IO YamlNode 
    353 parseNode SyckMap parser syckNode len nid = do 
     343parseNode :: SyckKind -> SyckParser -> SyckNode -> CLong -> IO YamlNode 
     344parseNode SyckMap parser syckNode len = do 
    354345    tag   <- syckNodeTag syckNode 
    355346    pairs <- (`mapM` [0..len-1]) $ \idx -> do 
    … …  
    359350        val     <- readNode parser valId 
    360351        return (key, val) 
    361     return $ nilNode{ n_elem = EMap pairs, n_tag = tag, n_id = nid } 
    362  
    363 parseNode SyckSeq parser syckNode len nid = do 
     352    return $ nilNode{ n_elem = EMap pairs, n_tag = tag} 
     353 
     354parseNode SyckSeq parser syckNode len = do 
    364355    tag   <- syckNodeTag syckNode 
    365356    nodes <- (`mapM` [0..len-1]) $ \idx -> do 
    366357        symId   <- syck_seq_read syckNode idx 
    367358        readNode parser symId 
    368     return $ nilNode{ n_elem = ESeq nodes, n_tag = tag, n_id = nid } 
    369  
    370 parseNode SyckStr _ syckNode len nid = do 
     359    return $ nilNode{ n_elem = ESeq nodes, n_tag = tag } 
     360 
     361parseNode SyckStr _ syckNode len = do 
    371362    tag   <- syckNodeTag syckNode 
    372363    cstr  <- syck_str_read syckNode 
    373364    buf   <- copyCStringLen (cstr, fromEnum len) 
    374     let node = nilNode{ n_elem = EStr buf, n_tag = tag, n_id = nid } 
     365    let node = nilNode{ n_elem = EStr buf, n_tag = tag } 
    375366    if tag == Nothing && Buf.length buf == 1 && Buf.index buf 0 == '~' 
    376367        then do