Changeset 19957 for third-party

Timestamp:

02/20/08 17:18:00 (9 months ago)

Author:

gwern

Message:

Update HsSyck? to merge in the Haddock documentation and the Cabal sdist improvements which constituted 0.3 and 0.4. This version also updates hsSyck to work with modern ByteStrings?, bytestring>=0.9.0.1, which is the oldest one packaged with GHC 6.8.x. (You can get this and hsregex on Hackage as well.)

Location:

third-party/HsSyck

Files:

• Changes (added)
• Data/Yaml/Syck.hsc (modified) (13 diffs)
• pugs-HsSyck.cabal (modified) (1 diff)

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

@@ -25 +25 @@
 import qualified Data.HashTable as Hash
 import qualified Data.ByteString.Char8 as Buf
-import Data.ByteString.Char8 (copyCStringLen, useAsCStringLen, useAsCString, copyCString)
+import Data.ByteString.Char8 (useAsCStringLen, useAsCString)
+import Data.ByteString.Unsafe (unsafePackCString, unsafePackCStringLen)
 
 type Buf        = Buf.ByteString
@@ -65 +66 @@
 type SyckBadAnchorHandler = SyckParser -> CString -> IO SyckNodePtr
 type SyckNodePtr = Ptr CString
-type SyckEmitter = Ptr ()  
+type SyckEmitter = Ptr ()
 type SyckEmitterHandler = SyckEmitter -> Ptr () -> IO ()
 type SyckOutputHandler = SyckEmitter -> CString -> CLong -> IO ()
@@ -77 +78 @@
 nilNode = MkNode maxId ENil Nothing ASingleton
 
+-- | Convert a ByteString buffer into a regular Haskell string
+
 {-# INLINE unpackBuf #-}
 unpackBuf :: Buf -> String
 unpackBuf = Buf.unpack
+
+-- | Convert a regular Haskell string into a ByteString buffer
 
 {-# INLINE packBuf #-}
@@ -107 +112 @@
 type EmitterExtras = Ptr ()
 -}
+
+-- | Dump a YAML node into a ByteString buffer (fast)
 
 emitYamlBytes :: YamlNode -> IO Buf
@@ -114 +121 @@
         out    <- newIORef []
         #{poke SyckEmitter, style} emitter scalarFold
-        -- #{poke SyckEmitter, sort_keys} emitter (1 :: CInt)
         #{poke SyckEmitter, anchor_format} emitter (Ptr "%d"## :: CString)
 
@@ -131 +137 @@
         fmap (Buf.concat . reverse) (readIORef out)
 
+-- | Given a file name, dump a YAML node into that file
+
 emitYamlFile :: FilePath -> YamlNode -> IO ()
 emitYamlFile file node = do
     buf <- emitYamlBytes node
     Buf.writeFile file buf
+
+-- | Dump a YAML node into a regular Haskell string
 
 emitYaml :: YamlNode -> IO String
@@ -159 +169 @@
 outputCallbackPS :: IORef [Buf] -> SyckEmitter -> CString -> CLong -> IO ()
 outputCallbackPS out emitter buf len = do
-    str <- copyCStringLen (buf, fromEnum len)
+    str <- unsafePackCStringLen (buf, fromEnum len)
     str `seq` modifyIORef out (str:)
 
@@ -183 +193 @@
 emitNode _ e n | EStr s <- n_elem n = do
     withTag n (Ptr "string"##) $ \tag ->
-        useAsCStringLen s $ \(cs, l) ->       
+        useAsCStringLen s $ \(cs, l) ->
         syck_emit_scalar e tag scalarFold 0 0 0 cs (toEnum l)
 
 emitNode freeze e n | ESeq sq <- n_elem n = do
     withTag n (Ptr "array"##) $ \tag ->
-        syck_emit_seq e tag seqInline
---      syck_emit_seq e tag seqNone
+--        syck_emit_seq e tag seqInline
+      syck_emit_seq e tag seqNone
     mapM_ (syck_emit_item e) =<< mapM freeze sq
     syck_emit_end e
@@ -195 +205 @@
 emitNode freeze e n | EMap m <- n_elem n = do
     withTag n (Ptr "map"##) $ \tag ->
-        syck_emit_map e tag mapInline
---      syck_emit_map e tag mapNone
+--        syck_emit_map e tag mapInline
+      syck_emit_map e tag mapNone
     flip mapM_ m (\(k,v) -> do
         syck_emit_item e =<< freeze k
@@ -205 +215 @@
 withTag node def f = maybe (f def) (`useAsCString` f) (n_tag node)
 
+-- | Parse a regular Haskell string
+
 parseYaml :: String -> IO YamlNode
 parseYaml = (`withCString` parseYamlCStr)
 
+-- | Given a file name, parse contents of file
+
 parseYamlFile :: String -> IO YamlNode
 parseYamlFile file = parseYamlBytes =<< Buf.readFile file
+
+-- | Parse a ByteString buffer (this is faster)
 
 parseYamlBytes :: Buf -> IO YamlNode
@@ -334 +350 @@
     tag <- #{peek SyckNode, type_id} syckNode
     if (tag == nullPtr) then (return Nothing) else do
-        p <- copyCString tag
+        p <- unsafePackCString tag
         return $! case Buf.elemIndex '/' p of
             Just n -> let { pre = Buf.take n p; post = Buf.drop (n+1) p } in
@@ -371 +387 @@
     tag   <- syckNodeTag syckNode
     cstr  <- syck_str_read syckNode
-    buf   <- copyCStringLen (cstr, fromEnum len)
+    buf   <- unsafePackCStringLen (cstr, fromEnum len)
     let node = nilNode{ n_elem = EStr buf, n_tag = tag, n_id = nid }
     if tag == Nothing && Buf.length buf == 1 && Buf.index buf 0 == '~'
@@ -381 +397 @@
         else return node
 
-foreign import ccall "wrapper"  
+foreign import ccall "wrapper"
     mkNodeCallback :: SyckNodeHandler -> IO (FunPtr SyckNodeHandler)
 
-foreign import ccall "wrapper"  
+foreign import ccall "wrapper"
     mkErrorCallback :: SyckErrorHandler -> IO (FunPtr SyckErrorHandler)
 
-foreign import ccall "wrapper"  
+foreign import ccall "wrapper"
     mkBadHandlerCallback :: SyckBadAnchorHandler -> IO (FunPtr SyckBadAnchorHandler)
 

third-party/HsSyck/pugs-HsSyck.cabal

@@ -1 +1 @@
 Name:                pugs-HsSyck
-Version:             0.2
-Description:         Fast, lightweight YAML loader and dumper
--- License is really "MIT", but Cabal allows no such field
-License:             BSD3
-License-file:        LICENSE
+Version:             0.41
+Category:            Text
+Synopsis:            Fast, lightweight YAML loader and dumper
+Description:         This is a simple YAML ('Yet Another Markup Language') processor,
+                     used by the Pugs project for handling data serialization; this can be
+                     useful for optimization and caching purposes.
+                     .
+                     This is an interface to the @syck@ C library for parsing and
+                     dumping YAML data. It lets you transform textual YAML data into an
+                     object of type 'YamlNode', and vice versa, fast.
+
+-- License is really "MIT", but Cabal doesn't have that constant yet
+License:             OtherLicense
+License-File:        LICENSE
 Author:              Audrey Tang
 Maintainer:          audreyt@audreyt.org
-Build-Depends:       base
+Copyright:           Audrey Tang, Gaal Yahas, 2005, 2006, 2007
+
 Exposed-modules:     Data.Yaml.Syck
+
+Build-Depends:       base, bytestring>=0.9.0.1
+Build-Type:          Simple
+Tested-With:         GHC==6.8.2
+
 extensions:          ForeignFunctionInterface
-ghc-options:         -fglasgow-exts -O2 -optc-w -funbox-strict-fields -fno-warn-orphans
+ghc-options:         -O2 -optc-w -funbox-strict-fields -fglasgow-exts
+
+data-files:          Changes
 c-sources:           syck/bytecode.c syck/emitter.c syck/gram.c syck/handler.c
                      syck/implicit.c syck/node.c syck/syck.c syck/syck_st.c syck/token.c
-                     syck/yaml2byte.c 
+                     syck/yaml2byte.c
 extra-source-files:  syck/syck.h syck/syck_st.h syck/gram.h syck/yamlbyte.h
 include-dirs:        syck