fixup! Avoid per-byte loop in cstring{,Utf8} builders

Matthew Craven review fixes

Author: hs-viktor

Data/ByteString/Builder/Internal.hs

@@ -1,7 +1,7 @@
-{-# LANGUAGE MagicHash #-}
-{-# LANGUAGE NoMonoLocalBinds #-}
-{-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE Unsafe #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE NoMonoLocalBinds #-}
 {-# LANGUAGE ViewPatterns #-}
 
 {-# OPTIONS_HADDOCK not-home #-}
@@ -979,11 +979,11 @@ byteStringInsert =
 -- Raw CString encoding
 ------------------------------------------------------------------------------
 
--- | Builder for raw 'Addr#' pointers to null-terminated primitive ASCII
--- strings that are free of embedded (overlong-encoded as the two-byte sequence
--- @0xC0 0x80@) null characters.
+-- | Builder for raw pointers to static data of known length that will never be
+-- moved or freed.  (This is used with the static buffers GHC uses to implement
+-- ASCII string literals that do not contain null characters.)
 --
--- @since 0.11.5.0
+-- @since 0.13.0.0
 {-# INLINABLE asciiLiteralCopy #-}
 asciiLiteralCopy :: Ptr Word8 -> Int -> Builder
 asciiLiteralCopy = \ !ip !len -> builder $ \k br@(BufferRange op ope) ->
@@ -996,7 +996,7 @@ asciiLiteralCopy = \ !ip !len -> builder $ \k br@(BufferRange op ope) ->
 -- as @0xC0 0x80@.  Other deviations from strict UTF-8 are tolerated, but the
 -- result is not well defined.
 --
--- @since 0.11.5.0
+-- @since 0.13.0.0
 {-# INLINABLE modUtf8LitCopy #-}
 modUtf8LitCopy :: Ptr Word8 -> Int -> Builder
 modUtf8LitCopy !ip !len
@@ -1034,14 +1034,15 @@ modUtf8_step !ip !len k (BufferRange op ope)
 utf8_copyBytes :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO Int
 utf8_copyBytes !ipe = \ ip op -> go 0 ip op
   where
+    go :: Int -> Ptr Word8 -> Ptr Word8 -> IO Int
     go !n !ip@((< ipe) -> True) !op = do
         !ch <- peek ip
         let !ip' = ip `plusPtr` 1
             !op' = op `plusPtr` 1
         if | ch /= 0xC0 -> do
                poke op ch
                let !cnt = ipe `minusPtr` ip'
-               !runend <- S.memchr ip' 0xC0 (fromIntegral cnt)
+               !runend <- S.memchr ip' 0xC0 (fromIntegral @Int cnt)
                let !runlen | runend == nullPtr = cnt
                            | otherwise = runend `minusPtr` ip'
                if (runlen == 0)

Data/ByteString/Builder/Prim.hs

@@ -1,8 +1,5 @@
-{-# LANGUAGE CPP #-}
 {-# LANGUAGE Trustworthy #-}
 
-#include "bytestring-cpp-macros.h"
-
 {- | Copyright : (c) 2010-2011 Simon Meier
                  (c) 2010      Jasper van der Jeugt
 License        : BSD3-style (see LICENSE)
@@ -456,6 +453,7 @@ import           Data.ByteString.Builder.Internal
 
 import qualified Data.ByteString               as S
 import qualified Data.ByteString.Internal      as S
+import qualified Data.ByteString.Internal.Type as S
 import qualified Data.ByteString.Lazy.Internal as L
 
 import           Data.Char (ord)
@@ -466,9 +464,6 @@ import           Data.ByteString.Builder.Prim.Binary
 import           Data.ByteString.Builder.Prim.ASCII
 
 import           Foreign
-#if !MIN_VERSION_base(4,15,0)
-import           Foreign.C (CSize(..), CString)
-#endif
 import           Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)
 import           GHC.Exts
 
@@ -667,7 +662,7 @@ primMapLazyByteStringBounded w =
 --
 -- @since 0.11.0.0
 cstring :: Addr# -> Builder
-cstring s = asciiLiteralCopy (Ptr s) (byteCountLiteral s)
+cstring s = asciiLiteralCopy (Ptr s) (S.byteCountLiteral s)
 {-# INLINE cstring #-}
 
 -- | Builder for raw 'Addr#' pointers to null-terminated primitive UTF-8
@@ -676,23 +671,9 @@ cstring s = asciiLiteralCopy (Ptr s) (byteCountLiteral s)
 --
 -- @since 0.11.0.0
 cstringUtf8 :: Addr# -> Builder
-cstringUtf8 s = modUtf8LitCopy (Ptr s) (byteCountLiteral s)
+cstringUtf8 s = modUtf8LitCopy (Ptr s) (S.byteCountLiteral s)
 {-# INLINE cstringUtf8 #-}
 
--- | Byte count of null-terminated primitive literal string excluding the
--- terminating null byte.
-byteCountLiteral :: Addr# -> Int
-byteCountLiteral addr# =
-#if HS_cstringLength_AND_FinalPtr_AVAILABLE
-  I# (cstringLength# addr#)
-#else
-  fromIntegral (pure_strlen (Ptr addr#))
-
-foreign import ccall unsafe "string.h strlen" pure_strlen
-    :: CString -> CSize
-#endif
-{-# INLINE byteCountLiteral #-}
-
 ------------------------------------------------------------------------------
 -- Char8 encoding
 ------------------------------------------------------------------------------

Data/ByteString/Internal/Type.hs

@@ -42,6 +42,7 @@ module Data.ByteString.Internal.Type (
         unpackChars, unpackAppendCharsLazy, unpackAppendCharsStrict,
         unsafePackAddress, unsafePackLenAddress,
         unsafePackLiteral, unsafePackLenLiteral,
+        byteCountLiteral,
 
         -- * Low level imperative construction
         empty,
@@ -475,6 +476,18 @@ unsafePackLenAddress len addr# = do
 #endif
 {-# INLINE unsafePackLenAddress #-}
 
+-- | Byte count of null-terminated primitive literal string excluding the
+-- terminating null byte.
+byteCountLiteral :: Addr# -> Int
+byteCountLiteral addr# =
+#if HS_cstringLength_AND_FinalPtr_AVAILABLE
+  I# (cstringLength# addr#)
+#else
+  fromIntegral @CSize @Int $
+    accursedUnutterablePerformIO (c_strlen (Ptr addr#))
+#endif
+{-# INLINE byteCountLiteral #-}
+
 -- | See 'unsafePackAddress'. This function has similar behavior. Prefer
 -- this function when the address in known to be an @Addr#@ literal. In
 -- that context, there is no need for the sequencing guarantees that 'IO'

bench/BenchAll.hs

@@ -327,8 +327,6 @@ main = do
         , benchB'_ "ASCII String (12B)" $ asciiLit (Ptr "hello wurld!"#)
         , benchB'  "ASCII String (64B, naive)" asciiStr fromString
         , benchB'_ "ASCII String (64B)" $ asciiLit asciiBuf
-        , benchB'_ "AsciiLit"      $ asciiLit asciiBuf
-        , benchB'_ "Utf8Lit"       $ utf8Lit utf8Buf
         , benchB'_ "strLit"        $ string8 asciiStr
         , benchB'_ "stringUtf8"    $ stringUtf8 utf8Str
         , benchB'_ "strLitInline"  $ string8 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"