HsSVN (empty) → 0.1
raw patch · 25 files changed
+7232/−0 lines, 25 filesdep +basedep +mtlbuild-type:Customsetup-changed
Dependencies added: base, mtl
Files
- COPYING +29/−0
- HsSVN.buildinfo.in +2/−0
- HsSVN.cabal +62/−0
- Setup.hs +4/−0
- Subversion.hsc +43/−0
- Subversion/Config.hsc +30/−0
- Subversion/Error.hsc +133/−0
- Subversion/FileSystem.hsc +261/−0
- Subversion/FileSystem/DirEntry.hsc +41/−0
- Subversion/FileSystem/PathChange.hsc +59/−0
- Subversion/FileSystem/Revision.hsc +214/−0
- Subversion/FileSystem/Root.hsc +331/−0
- Subversion/FileSystem/Transaction.hsc +338/−0
- Subversion/Hash.hsc +246/−0
- Subversion/Pool.hsc +35/−0
- Subversion/Repository.hsc +234/−0
- Subversion/Stream.hsc +164/−0
- Subversion/String.hsc +65/−0
- Subversion/Types.hsc +106/−0
- cbits/HsSVN.c +28/−0
- cbits/HsSVN.h +19/−0
- configure +4698/−0
- configure.ac +46/−0
- examples/HelloWorld.hs +32/−0
- examples/Makefile +12/−0
+ COPYING view
@@ -0,0 +1,29 @@+<!-- -*- xml -*-++HsSVN はパブリックドメインに在ります。+HsSVN is in the public domain.++See http://creativecommons.org/licenses/publicdomain/++-->++<rdf:RDF xmlns="http://web.resource.org/cc/"+ xmlns:dc="http://purl.org/dc/elements/1.1/"+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">+ <Work rdf:about="http://ccm.sherry.jp/HsSVN/">+ <dc:title>HsSVN</dc:title>+ <dc:rights>+ <Agent>+ <dc:title>phonohawk</dc:title>+ </Agent>+ </dc:rights>+ <license rdf:resource="http://web.resource.org/cc/PublicDomain" />+ </Work>+ + <License rdf:about="http://web.resource.org/cc/PublicDomain">+ <permits rdf:resource="http://web.resource.org/cc/Reproduction" />+ <permits rdf:resource="http://web.resource.org/cc/Distribution" />+ <permits rdf:resource="http://web.resource.org/cc/DerivativeWorks" />+ </License>++</rdf:RDF>
+ HsSVN.buildinfo.in view
@@ -0,0 +1,2 @@+cc-options: @SVN_CFLAGS@+ld-options: @SVN_LIBS@
+ HsSVN.cabal view
@@ -0,0 +1,62 @@+Name: + HsSVN+Synopsis: + (Part of) Subversion binding for Haskell+Description:+ HsSVN is a (part of) Subversion binding for Haskell. Currently it+ can do most things related to the Subversion FS but others are+ left uncovered.+Version: + 0.1+License: + PublicDomain+License-File:+ COPYING+Author: + PHO <phonohawk at ps dot sakura dot ne dot jp>+Maintainer: + PHO <phonohawk at ps dot sakura dot ne dot jp>+Stability:+ experimental+Homepage: + http://ccm.sherry.jp/HsSVN/+Category: + System+Tested-With: + GHC == 6.6.1+Build-Depends:+ base, mtl+Exposed-Modules:+ Subversion+ Subversion.Config+ Subversion.FileSystem+ Subversion.FileSystem.DirEntry+ Subversion.FileSystem.PathChange+ Subversion.FileSystem.Revision+ Subversion.FileSystem.Root+ Subversion.FileSystem.Transaction+ Subversion.Error+ Subversion.Repository+ Subversion.Types+Other-Modules:+ Subversion.Hash+ Subversion.Pool+ Subversion.Stream+ Subversion.String+Extensions:+ ForeignFunctionInterface, EmptyDataDecls+GHC-Options: + -fwarn-unused-imports -O3+C-Sources:+ cbits/HsSVN.c+Include-Dirs:+ cbits+Install-Includes:+ HsSVN.h+Extra-Source-Files:+ HsSVN.buildinfo.in+ cbits/HsSVN.h+ configure+ configure.ac+ examples/Makefile+ examples/HelloWorld.hs
+ Setup.hs view
@@ -0,0 +1,4 @@+#!/usr/bin/env runghc++import Distribution.Simple+main = defaultMainWithHooks defaultUserHooks
+ Subversion.hsc view
@@ -0,0 +1,43 @@+{- -*- haskell -*- -}++-- |HsSVN is a (part of) Subversion binding for Haskell. Currently it+-- can do most things related to the Subversion FS but others are left+-- uncoverd.+--+-- If you find out any features you want aren't supported, you must+-- write your own patch (or take over the HsSVN project). Happy+-- hacking.++#include "HsSVN.h"++module Subversion+ ( withSubversion+ )+ where++import Control.Exception+import Subversion.Error+++foreign import ccall "HsSVN_initialize"+ _initialize :: IO Int+++-- |Computation of @'withSubversion' action@ initializes the+-- Subversion library and computes @action@. Every applications that+-- use HsSVN must wrap any operations related to Subversion with+-- 'withSubversion', or they will crash.+withSubversion :: IO a -> IO a+withSubversion f+ = do ret <- _initialize+ case ret of+ 0 -> catchDyn f rethrowSvnError+ _ -> fail "Subversion: failed to initialize APR."+++rethrowSvnError :: SvnError -> IO a+rethrowSvnError err+ = let code = svnErrCode err+ msg = svnErrMsg err+ in+ fail $ "withSubversion: caught an SvnError: " ++ (show code) ++ ": " ++ msg
+ Subversion/Config.hsc view
@@ -0,0 +1,30 @@+{- -*- haskell -*- -}++-- |An interface to client configuration files (svn_config.h).+--+-- As you see, this module is totally incomplete. If you need this,+-- you must write a patch.++module Subversion.Config+ ( Config+ )+ where++import GHC.ForeignPtr as GF+import Subversion.Hash++-- |@'Config'@ represents an opaque structure describing a set of+-- configuration options. There is currently no way to neither create+-- nor inspect this object.+newtype Config = Config (ForeignPtr SVN_CONFIG_T)+data SVN_CONFIG_T+++instance HashValue Config where+ marshal (Config config)+ = return $ castForeignPtr config++ unmarshal finalizer configPtr+ = do config <- newForeignPtr_ configPtr+ GF.addForeignPtrConcFinalizer config finalizer+ return $ Config $ castForeignPtr config
+ Subversion/Error.hsc view
@@ -0,0 +1,133 @@+{- -*- haskell -*- -}++-- #prune++-- |Common exception handling for Subversion. The C API of the+-- Subversion returns an error as a function result, but in HsSVN+-- errors are thrown as a DynException.++#include "HsSVN.h"++module Subversion.Error+ ( SvnError+ , SVN_ERROR_T -- private++ , wrapSvnError -- private++ , svnErrCode+ , svnErrMsg++ , svnErr -- private++ , throwSvnErr++ , SvnErrCode(..)+ )+ where++import Control.Exception+import Data.Dynamic+import Foreign+import Foreign.C.String+import Foreign.C.Types+import Subversion.Types++-- |@'SvnError'@ represents a Subversion error.+newtype SvnError+ = SvnError (ForeignPtr SVN_ERROR_T)+ deriving (Typeable)++data SVN_ERROR_T+++foreign import ccall "svn_err_best_message"+ _best_message :: Ptr SVN_ERROR_T -> Ptr CChar -> APR_SIZE_T -> IO (Ptr CChar)++foreign import ccall "&svn_error_clear"+ _clear :: FunPtr (Ptr SVN_ERROR_T -> IO ())+++maxErrMsgLen :: Int+maxErrMsgLen = 255+++withSvnErrorPtr :: SvnError -> (Ptr SVN_ERROR_T -> IO a) -> IO a+withSvnErrorPtr (SvnError err) = withForeignPtr err++-- |@'svnErrCode' err@ returns a 'SvnErrCode' for an error object.+svnErrCode :: SvnError -> SvnErrCode+svnErrCode err+ = unsafePerformIO $+ withSvnErrorPtr err $ \ errPtr -> + do num <- (#peek svn_error_t, apr_err) errPtr+ return $ statusToErrCode num++-- |@'svnErrMsg' err@ returns an error message for an error object.+svnErrMsg :: SvnError -> String+svnErrMsg err+ = unsafePerformIO $+ withSvnErrorPtr err $ \ errPtr ->+ allocaArray maxErrMsgLen $ \ bufPtr ->+ _best_message errPtr bufPtr (fromIntegral maxErrMsgLen)+ >>= peekCString+++wrapSvnError :: Ptr SVN_ERROR_T -> IO (Maybe SvnError)+wrapSvnError errPtr+ | errPtr == nullPtr+ = return Nothing+ | otherwise+ = newForeignPtr _clear errPtr >>= return . Just . SvnError+++svnErr :: IO (Ptr SVN_ERROR_T) -> IO ()+svnErr f+ = do err <- wrapSvnError =<< f+ case err of+ Nothing -> return ()+ Just e -> throwSvnErr e++-- |@'throwSvnErr' err@ throws an 'SvnError' object in an IO+-- monad. You usually don't need to use this directly.+throwSvnErr :: SvnError -> IO a+throwSvnErr = throwIO . DynException . toDyn++-- |@'SvnErrCode'@ represents a Subversion error code. As you see, not+-- all errors are translated to Haskell constructors yet. Uncovered+-- error codes are temporarily represented as @'UnknownError' num@.+data SvnErrCode+ = AprEEXIST -- ^ APR EEXIST error: typically it means+ -- something you tried to create was already+ -- there.+ | AprENOENT -- ^ APR ENOENT error: typically it means+ -- something you tried to use wasn't there.+ | DirNotEmpty -- ^ The directory needs to be empty but it's not.+ | ReposLocked -- ^ The repository was locked, perhaps for db+ -- recovery.+ | FsAlreadyExists -- ^ The item already existed in filesystem.+ | FsConflict -- ^ Merge conflict has occured during commit.+ | FsNoSuchRevision -- ^ It was an invalid filesystem revision+ -- number.+ | FsNotDirectory -- ^ It was not a filesystem directory entry.+ | FsNotFile -- ^ It was not a filesystem file entry.+ | FsNotFound -- ^ It wasn't there in filesystem.+ | UnknownError !Int -- ^ Any other errors than above. You+ -- shouldn't rely on the absence of+ -- appropriate 'SvnErrCode' constructors+ -- because they may be added in the future+ -- version of HsSVN. If that happens to you,+ -- your code stops working.+ deriving (Show, Eq, Typeable)++statusToErrCode :: APR_STATUS_T -> SvnErrCode+statusToErrCode (#const APR_EEXIST ) = AprEEXIST+statusToErrCode (#const APR_ENOENT ) = AprENOENT+statusToErrCode (#const SVN_ERR_DIR_NOT_EMPTY ) = DirNotEmpty+statusToErrCode (#const SVN_ERR_REPOS_LOCKED ) = ReposLocked+statusToErrCode (#const SVN_ERR_FS_ALREADY_EXISTS ) = FsAlreadyExists+statusToErrCode (#const SVN_ERR_FS_CONFLICT ) = FsConflict+statusToErrCode (#const SVN_ERR_FS_NO_SUCH_REVISION) = FsNoSuchRevision+statusToErrCode (#const SVN_ERR_FS_NOT_DIRECTORY ) = FsNotDirectory+statusToErrCode (#const SVN_ERR_FS_NOT_FILE ) = FsNotFile+statusToErrCode (#const SVN_ERR_FS_NOT_FOUND ) = FsNotFound+statusToErrCode n = UnknownError (fromIntegral n)
+ Subversion/FileSystem.hsc view
@@ -0,0 +1,261 @@+{- -*- haskell -*- -}++-- #prune++-- |An interface to the Subversion filesystem.++#include "HsSVN.h"++module Subversion.FileSystem+ ( -- * Type+ FileSystem+ , SVN_FS_T -- private++ , wrapFS -- private+ , withFSPtr -- private+ , touchFS -- private++ -- * Information of the libsvn_fs itself+ , fsVersion++ -- * Filesystem creation, opening and destruction+ , createFileSystem+ , fsConfigFSType+ , fsTypeBDB+ , fsTypeFSFS++ , openFileSystem+ , deleteFileSystem+ , hotCopyFileSystem++ -- * Accessors+ , getFileSystemType+ , getFileSystemPath++ , getYoungestRev+ )+ where++import Control.Monad+import Foreign.C.String+import Foreign.ForeignPtr+import Foreign.Ptr+import Foreign.Marshal.Alloc+import Foreign.Storable+import GHC.ForeignPtr as GF+import Subversion.Error+import Subversion.Hash+import Subversion.Pool+import Subversion.Types++-- |@'FileSystem'@ is an opaque object representing a Subversion+-- filesystem.+newtype FileSystem = FileSystem (ForeignPtr SVN_FS_T)+data SVN_FS_T++foreign import ccall "svn_fs_version"+ _version :: IO (Ptr SVN_VERSION_T)++foreign import ccall "svn_fs_create"+ _create :: Ptr (Ptr SVN_FS_T) -> CString -> Ptr APR_HASH_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall "svn_fs_open"+ _open :: Ptr (Ptr SVN_FS_T) -> CString -> Ptr APR_HASH_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall "svn_fs_delete_fs"+ _delete_fs :: CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall "svn_fs_hotcopy"+ _hotcopy :: CString -> CString -> SVN_BOOLEAN_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall "svn_fs_type"+ _type :: Ptr CString -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall "svn_fs_path"+ _path :: Ptr SVN_FS_T -> Ptr APR_POOL_T -> IO CString++foreign import ccall "svn_fs_youngest_rev"+ _youngest_rev :: Ptr SVN_REVNUM_T -> Ptr SVN_FS_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)+++wrapFS :: IO () -> Ptr SVN_FS_T -> IO FileSystem+wrapFS finalizer fsPtr+ = do fs <- newForeignPtr_ fsPtr+ GF.addForeignPtrConcFinalizer fs finalizer+ return $ FileSystem fs+++withFSPtr :: FileSystem -> (Ptr SVN_FS_T -> IO a) -> IO a+withFSPtr (FileSystem fs) = withForeignPtr fs+++touchFS :: FileSystem -> IO ()+touchFS (FileSystem fs) = touchForeignPtr fs++-- |@fsVersion@ returns a version information of the libsvn_fs.+fsVersion :: IO Version+fsVersion = _version >>= peekVersion+++-- |@'fsConfigFSType'@ is a config key to specify the filesystem+-- back-end.+fsConfigFSType :: String+fsConfigFSType = (#const_str SVN_FS_CONFIG_FS_TYPE)++-- |@'fsTypeBDB'@ is a config value representing the Berkeley-DB+-- back-end.+fsTypeBDB :: String+fsTypeBDB = (#const_str SVN_FS_TYPE_BDB)++-- |@'fsTypeFSFS'@ is a config value representing the+-- Native-filesystem back-end.+fsTypeFSFS :: String+fsTypeFSFS = (#const_str SVN_FS_TYPE_FSFS)++-- |@'createFileSystem'@ creates a new, empty Subversion+-- filesystem. Note that creating a raw filesystem is different from+-- creating a repository. If you want a new repository, use+-- 'Subversion.Repository.createRepository' instead.+createFileSystem+ :: FilePath -- ^ Where to create the filesystem. The+ -- path most not currently exist, but its+ -- parent must exist.+ -> [(String, String)] -- ^ A list of @(key, value)@ tuples which+ -- modifies the behavior of the+ -- filesystem. The interpretation of it is+ -- specific to the filesystem back-end.+ -- + -- If the list contains a value for+ -- 'fsConfigFSType', that value determines+ -- the filesystem type for the new+ -- filesystem. Currently defined values+ -- are:+ --+ -- ['fsTypeBDB'] Berkeley-DB implementation+ --+ -- ['fsTypeFSFS'] Native-filesystem+ -- implementation+ --+ -- If the list does not contain a value+ -- for 'fsConfigFSType' then the default+ -- filesystem type will be used. This will+ -- typically be BDB for version 1.1 and+ -- FSFS for later versions, though the+ -- caller should not rely upon any+ -- particular default if they wish to+ -- ensure that a filesystem of specific+ -- type is created.+ -> IO FileSystem -- ^ The new filesystem.+createFileSystem path configPairs+ = do pool <- newPool+ alloca $ \ fsPtrPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do config <- pairsToHash configPairs+ svnErr $ _create fsPtrPtr pathPtr (unsafeHashToPtr config) poolPtr++ fs <- wrapFS (touchPool pool) =<< peek fsPtrPtr++ -- config には fs が死ぬまでは生きてゐて慾しい。+ GF.addForeignPtrConcFinalizer (case fs of FileSystem x -> x)+ $ touchHash config++ return fs++-- |@'openFileSystem'@ opens a Subversion filesystem. Note that you+-- probably don't want to use this directly. Take a look at+-- 'Subversion.Repository.openRepository' instead.+openFileSystem+ :: FilePath -- ^ Where the filesystem located on.+ -> [(String, String)] -- ^ A list of @(key, value)@ tuples which+ -- modifies the behavior of the+ -- filesystem. The interpretation of it is+ -- specific to the filesystem back-end.+ -> IO FileSystem+openFileSystem path configPairs+ = do pool <- newPool+ alloca $ \ fsPtrPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do config <- pairsToHash configPairs+ svnErr $ _open fsPtrPtr pathPtr (unsafeHashToPtr config) poolPtr++ fs <- wrapFS (touchPool pool) =<< peek fsPtrPtr++ -- config には fs が死ぬまでは生きてゐて慾しい。+ GF.addForeignPtrConcFinalizer (case fs of FileSystem x -> x)+ $ touchHash config++ return fs++-- |@'deleteFileSystem'@ deletes a Subversion filesystem. Note that+-- you probably don't want to use this directly. Take a look at+-- 'Subversion.Repository.deleteRepository' instead.+deleteFileSystem :: FilePath -> IO ()+deleteFileSystem path+ = do pool <- newPool+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ svnErr $ _delete_fs pathPtr poolPtr++-- |@'hotCopyFileSystem'@ copies a possibly live Subversion filesystem+-- from one location to another.+hotCopyFileSystem :: FilePath -- ^ Source+ -> FilePath -- ^ Destination+ -> Bool -- ^ If this is true,+ -- @'hotCopyFileSystem'@ performs+ -- cleanup on the source filesystem as+ -- part of the copy opeation;+ -- currently, this means deleting+ -- copied, unused logfiles for a+ -- Berkeley DB source filesystem.+ -> IO ()+hotCopyFileSystem src dest clean+ = do pool <- newPool+ withCString src $ \ srcPath ->+ withCString dest $ \ destPath ->+ withPoolPtr pool $ \ poolPtr ->+ svnErr $ _hotcopy srcPath destPath (marshalBool clean) poolPtr++-- |@'getFileSystemPath' fsPath@ returns a string identifying the+-- back-end type of the Subversion filesystem located on @fsPath@. The+-- string should be equal to one of the @fsType*@ defined constants,+-- unless the filesystem is a new back-end type added in a later+-- version of Subversion.+--+-- In general, the type should make no difference in the filesystem's+-- semantics, but there are a few situations (such as backups) where+-- it might matter.+getFileSystemType :: FilePath -> IO String+getFileSystemType path+ = do pool <- newPool+ alloca $ \ typePtrPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _type typePtrPtr pathPtr poolPtr+ t <- peekCString =<< peek typePtrPtr+ return t++-- |@'getFileSystemPath' fs@ returns the path to @fs@'s+-- repository. Note that this is what was passed to 'createFileSystem'+-- or 'openFileSystem'; might be absolute, might not.+getFileSystemPath :: FileSystem -> IO FilePath+getFileSystemPath fs+ = do pool <- newPool+ withFSPtr fs $ \ fsPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do path <- peekCString =<< _path fsPtr poolPtr+ touchPool pool+ return path++-- |@'getYoungestRev' fs@ returns the number of the youngest revision+-- in filesystem @fs@. The oldest revision in any filesystem is+-- numbered zero.+getYoungestRev :: FileSystem -> IO RevNum+getYoungestRev fs+ = do pool <- newPool+ alloca $ \ revNumPtr ->+ withFSPtr fs $ \ fsPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _youngest_rev revNumPtr fsPtr poolPtr+ return . fromIntegral =<< peek revNumPtr
+ Subversion/FileSystem/DirEntry.hsc view
@@ -0,0 +1,41 @@+{- -*- haskell -*- -}++-- |This module only defines the 'DirEntry' type.++#include "HsSVN.h"++module Subversion.FileSystem.DirEntry+ ( DirEntry(..)+ )+ where++import Foreign.C.String+import Foreign.Storable+import Subversion.Hash+import Subversion.Types++-- |The type of a Subversion directory entry.+--+-- Note that @svn_fs_dirent_t.id@ is currently unavailable in this+-- binding. Add one if you really need it.+data DirEntry+ = DirEntry {+ entName :: String -- ^ The name of this directory entry.+ , entKind :: NodeKind -- ^ The node kind.+ }+ deriving (Show, Eq)+++instance HashValue DirEntry where+ marshal ent+ = fail "marshalling DirEntry is not supported"++ unmarshal finalizer entPtr+ = do namePtr <- (#peek svn_fs_dirent_t, name) entPtr+ name <- peekCString namePtr+ kind <- (#peek svn_fs_dirent_t, kind) entPtr+ finalizer+ return DirEntry {+ entName = name+ , entKind = unmarshalNodeKind kind+ }
+ Subversion/FileSystem/PathChange.hsc view
@@ -0,0 +1,59 @@+{- -*- haskell -*- -}++-- |This module only defines two types; 'PathChange' and 'ChangeKind'.++#include "HsSVN.h"++module Subversion.FileSystem.PathChange+ ( PathChange(..)+ , ChangeKind(..)+ )+ where++import Data.Word+import Foreign.Storable+import Subversion.Hash+import Subversion.Types++-- |@'PathChange'@ describes a change in a revision occured on a path.+-- +-- Note that @svn_fs_path_change_t.node_rev_id@ is currently+-- unavailable in this binding. Add one if you really need it.+data PathChange = PathChange {+ pcChangeKind :: ChangeKind -- ^ Kind of change.+ , pcTextMod :: Bool -- ^ Were there text modifications?+ , pcPropMod :: Bool -- ^ Were there property modifications?+ } deriving (Show, Eq)+++type SVN_FS_PATH_CHANGE_KIND_T = #type svn_fs_path_change_kind_t++-- |The kind of change that occured on the path.+data ChangeKind = ModifiedPath -- ^ defalut value+ | AddedPath -- ^ path added in txn+ | DeletedPath -- ^ path removed in txn+ | ReplacedPath -- ^ path removed and re-added in txn+ deriving (Show, Eq)+++unmarshalChangeKind :: SVN_FS_PATH_CHANGE_KIND_T -> ChangeKind+unmarshalChangeKind (#const svn_fs_path_change_modify ) = ModifiedPath+unmarshalChangeKind (#const svn_fs_path_change_add ) = AddedPath+unmarshalChangeKind (#const svn_fs_path_change_delete ) = DeletedPath+unmarshalChangeKind (#const svn_fs_path_change_replace) = ReplacedPath+++instance HashValue PathChange where+ marshal pc+ = fail "marshalling PathChange is not supported"++ unmarshal finalizer pcPtr+ = do kind <- (#peek svn_fs_path_change_t, change_kind) pcPtr+ textMod <- (#peek svn_fs_path_change_t, text_mod ) pcPtr+ propMod <- (#peek svn_fs_path_change_t, prop_mod ) pcPtr+ finalizer+ return PathChange {+ pcChangeKind = unmarshalChangeKind kind+ , pcTextMod = unmarshalBool textMod+ , pcPropMod = unmarshalBool propMod+ }
+ Subversion/FileSystem/Revision.hsc view
@@ -0,0 +1,214 @@+{- -*- haskell -*- -}++-- |An interface to functions that work on an existing+-- (i.e. read-only) revision in a filesystem.++module Subversion.FileSystem.Revision+ ( -- * Type+ Rev++ -- * Running the monad+ , withRevision++ -- * Accessing revision property+ , getRevisionProp+ , getRevisionPropList+ , setRevisionProp++ -- * Getting node history+ , getNodeHistory+ )+ where++import Control.Monad.Reader+import qualified Data.ByteString.Char8 as B8+import Foreign.C.String+import Foreign.Storable+import Foreign.Marshal.Alloc+import Foreign.Ptr+import Subversion.Error+import Subversion.FileSystem+import Subversion.FileSystem.Root+import Subversion.Hash+import Subversion.Pool+import Subversion.String+import Subversion.Types+import System.IO.Unsafe+++{- Monad Rev ----------------------------------------------------------------- -}++-- |@'Rev' a@ is a FS monad which reads data from an existing revision+-- and finally returns @a@. See 'Subversion.FileSystem.Root.MonadFS'.+--+-- Since 'Rev' monad does no transactions,+-- 'Subversion.FileSystem.Root.unsafeIOToFS' isn't really unsafe. You+-- can do any I\/O actions in the monad if you wish.+newtype Rev a = Rev { unRev :: ReaderT FileSystemRoot IO a }++instance Functor Rev where+ fmap f c = Rev (fmap f (unRev c))++instance Monad Rev where+ c >>= f = Rev (unRev c >>= unRev . f)+ return = Rev . return+ fail = Rev . fail++instance MonadFS Rev where+ getRoot = Rev ask+ unsafeIOToFS a = Rev (liftIO a)+ isTransaction = Rev (return False)+++{- functions and types ------------------------------------------------------- -}++data SVN_FS_HISTORY_T+++foreign import ccall unsafe "svn_fs_revision_root"+ _revision_root :: Ptr (Ptr SVN_FS_ROOT_T) -> Ptr SVN_FS_T -> SVN_REVNUM_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_revision_prop"+ _revision_prop :: Ptr (Ptr SVN_STRING_T) -> Ptr SVN_FS_T -> SVN_REVNUM_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_revision_proplist"+ _revision_proplist :: Ptr (Ptr APR_HASH_T) -> Ptr SVN_FS_T -> SVN_REVNUM_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_change_rev_prop"+ _change_rev_prop :: Ptr SVN_FS_T -> SVN_REVNUM_T -> CString -> Ptr SVN_STRING_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_node_history"+ _node_history :: Ptr (Ptr SVN_FS_HISTORY_T) -> Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_history_prev"+ _history_prev :: Ptr (Ptr SVN_FS_HISTORY_T) -> Ptr SVN_FS_HISTORY_T -> SVN_BOOLEAN_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_history_location"+ _history_location :: Ptr CString -> Ptr SVN_REVNUM_T -> Ptr SVN_FS_HISTORY_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)+++getRevisionRoot :: FileSystem -> Int -> IO FileSystemRoot+getRevisionRoot fs revNum+ = do pool <- newPool+ alloca $ \ rootPtrPtr ->+ withFSPtr fs $ \ fsPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _revision_root rootPtrPtr fsPtr (fromIntegral revNum) poolPtr+ -- root は pool にも fs にも依存する。+ wrapFSRoot (touchPool pool >> touchFS fs)+ =<< peek rootPtrPtr++-- |@'withRevision'@ runs a 'Rev' monad in an IO monad.+withRevision :: FileSystem -> RevNum -> Rev a -> IO a+withRevision fs revNum c+ = getRevisionRoot fs revNum+ >>= runReaderT (unRev c)++-- |@'getRevisionProp' fs revNum propName@ returns the value of the+-- property named @propName@ on revision @revNum@ in the filesystem+-- @fs@.+getRevisionProp :: FileSystem -> RevNum -> String -> IO (Maybe String)+getRevisionProp fs revNum name+ = do pool <- newPool+ alloca $ \ valPtrPtr ->+ withFSPtr fs $ \ fsPtr ->+ withCString name $ \ namePtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _revision_prop valPtrPtr fsPtr (fromIntegral revNum) namePtr poolPtr+ prop <- peekSvnString' =<< peek valPtrPtr+ -- prop は pool の中から讀み取られるので、それが濟むま+ -- で pool が死んでは困る。+ touchPool pool+ return $ fmap B8.unpack prop++-- |@'getRevisionPropList' fs revNum@ returns the entire property list+-- of revision @revNum@ in filesystem @fs@.+getRevisionPropList :: FileSystem -> RevNum -> IO [(String, String)]+getRevisionPropList fs revNum+ = do pool <- newPool+ alloca $ \ hashPtrPtr ->+ withFSPtr fs $ \ fsPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _revision_proplist hashPtrPtr fsPtr (fromIntegral revNum) poolPtr+ hash <- wrapHash (touchPool pool) =<< peek hashPtrPtr+ mapHash' (\ (n, v)+ -> peekSvnString v+ >>=+ return . ((,) n) . B8.unpack) hash++-- |@'setRevisionProp'@ changes, adds or deletes a property on a+-- revision. Note that revision properties are non-historied: you can+-- change them after the revision has been comitted. They are not+-- protected via transactions.+setRevisionProp :: FileSystem -- ^ The transaction+ -> RevNum -- ^ The revision+ -> String -- ^ The property name+ -> Maybe String -- ^ The property value+ -> IO ()+setRevisionProp fs revNum name valStr+ = do pool <- newPool+ let value = fmap B8.pack valStr+ withFSPtr fs $ \ fsPtr ->+ withCString name $ \ namePtr ->+ withSvnString' value $ \ valuePtr ->+ withPoolPtr pool $ \ poolPtr ->+ svnErr $ _change_rev_prop fsPtr (fromIntegral revNum) namePtr valuePtr poolPtr++-- |@'getNodeHistory'@ /lazily/ reads the change history of given node+-- in a filesystem. The most recent change comes first in the+-- resulting list.+--+-- The revisions returned for a path will be older than or the same+-- age as the revision of that path in the target revision of 'Rev'+-- monad. That is, if the 'Rev' monad is running on revision @X@, and+-- the path was modified in some revisions younger than @X@, those+-- revisions younger than @X@ will not be included for the path.+getNodeHistory+ :: Bool -- ^ If this is true, stepping+ -- backwards in history would cross+ -- a copy operation. This is usually+ -- the desired behavior.+ -> FilePath -- ^ The path to node you want to read+ -- history.+ -> Rev [(RevNum, FilePath)] -- ^ A list of @(revNum, nodePath)@:+ -- the node was modified somehow at+ -- revision @revNum@, and at that+ -- time the node was located on+ -- @nodePath@.+getNodeHistory crossCopies path+ = do pool <- unsafeIOToFS $ newPool+ root <- getRoot+ unsafeIOToFS $ alloca $ \ histPtrPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _node_history histPtrPtr rootPtr pathPtr poolPtr+ lazyReadHist pool =<< peek histPtrPtr+ where+ lazyReadHist pool histPtr = unsafeInterleaveIO $ readHist pool histPtr++ readHist :: Pool -> Ptr SVN_FS_HISTORY_T -> IO [(RevNum, FilePath)]+ readHist pool histPtr+ = alloca $ \ histPtrPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _history_prev histPtrPtr histPtr (marshalBool crossCopies) poolPtr+ got <- peek histPtrPtr++ if got == nullPtr then+ -- ヒストリの終端に達した。これ以後、Pool は解放され+ -- ても構はない。+ touchPool pool >> return []+ else+ do x <- getHistLocation got pool+ xs <- lazyReadHist pool got+ return (x:xs)++ getHistLocation :: Ptr SVN_FS_HISTORY_T -> Pool -> IO (RevNum, FilePath)+ getHistLocation histPtr pool+ = alloca $ \ pathPtrPtr ->+ alloca $ \ revNumPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _history_location pathPtrPtr revNumPtr histPtr poolPtr+ revNum <- return . fromIntegral =<< peek revNumPtr+ path <- peekCString =<< peek pathPtrPtr+ return (revNum, path)
+ Subversion/FileSystem/Root.hsc view
@@ -0,0 +1,331 @@+{- -*- haskell -*- -}++-- #prune++-- |An interface to functions that work on both existing revisions and+-- ongoing transactions in a filesystem.++#include "HsSVN.h"++module Subversion.FileSystem.Root+ ( -- * Class+ MonadFS(..)++ , FileSystemRoot -- private+ , SVN_FS_ROOT_T -- private++ , wrapFSRoot -- private+ , withFSRootPtr -- private++ , getRootFS -- private++ -- * Getting file content and others+ , getFileLength+ , getFileMD5++ , getFileContents+ , getFileContentsLBS++ -- * Getting node type+ , checkPath+ , isDirectory+ , isFile++ -- * Getting node property+ , getNodeProp+ , getNodePropList++ -- * Getting nodes in directory+ , getDirEntries++ -- * Getting change list+ , getPathsChanged+ )+ where++import Control.Monad+import Data.ByteString.Base+import qualified Data.ByteString.Char8 as B8+import qualified Data.ByteString.Lazy.Char8 as L8+import Data.Word+import Foreign.C.String+import Foreign.C.Types+import Foreign.ForeignPtr+import Foreign.Marshal.Alloc+import Foreign.Marshal.Array+import Foreign.Ptr+import Foreign.Storable+import GHC.ForeignPtr as GF+import Subversion.FileSystem+import Subversion.FileSystem.DirEntry+import Subversion.FileSystem.PathChange+import Subversion.Error+import Subversion.Hash+import Subversion.Pool+import Subversion.Stream+import Subversion.String+import Subversion.Types+++{- class MonadFS ------------------------------------------------------------- -}++-- |@'MonadFS' m@ is a monad which holds internally either an existing+-- revision or ongoing transaction.+class Monad m => MonadFS m where+ -- private+ getRoot :: m FileSystemRoot++ -- |@'unsafeIOToFS'@ runs an IO monad in 'MonadFS'.+ -- + -- This is unsafe if the monad is a transaction monad. When a+ -- transaction fails before getting commited, all transactional+ -- operations are cancelled at once. But if you had launched+ -- missiles with 'unsafeIOToFS' during the transaction, your+ -- missiles can never go back. So you must use this carefully.+ unsafeIOToFS :: IO a -> m a++ -- |@'isTransaction'@ returns True iff the monad is a transaction+ -- monad.+ isTransaction :: m Bool+++{- functions and types ------------------------------------------------------- -}++newtype FileSystemRoot = FileSystemRoot (ForeignPtr SVN_FS_ROOT_T)+data SVN_FS_ROOT_T+++foreign import ccall unsafe "svn_fs_root_fs"+ _root_fs :: Ptr SVN_FS_ROOT_T -> IO (Ptr SVN_FS_T)++foreign import ccall unsafe "svn_fs_file_length"+ _file_length :: Ptr SVN_FILESIZE_T -> Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_file_md5_checksum"+ _file_md5_checksum :: Ptr CUChar -> Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_file_contents"+ _file_contents :: Ptr (Ptr SVN_STREAM_T) -> Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_node_proplist"+ _node_proplist :: Ptr (Ptr APR_HASH_T) -> Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_node_prop"+ _node_prop :: Ptr (Ptr SVN_STRING_T) -> Ptr SVN_FS_ROOT_T -> CString -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_dir_entries"+ _dir_entries :: Ptr (Ptr APR_HASH_T) -> Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_paths_changed"+ _paths_changed :: Ptr (Ptr APR_HASH_T) -> Ptr SVN_FS_ROOT_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_check_path"+ _check_path :: Ptr SVN_NODE_KIND_T -> Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_is_dir"+ _is_dir :: Ptr SVN_BOOLEAN_T -> Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_is_file"+ _is_file :: Ptr SVN_BOOLEAN_T -> Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)+++wrapFSRoot :: IO () -> Ptr SVN_FS_ROOT_T -> IO FileSystemRoot+wrapFSRoot finalizer rootPtr+ = do root <- newForeignPtr_ rootPtr+ GF.addForeignPtrConcFinalizer root finalizer+ return $ FileSystemRoot root+++withFSRootPtr :: FileSystemRoot -> (Ptr SVN_FS_ROOT_T -> IO a) -> IO a+withFSRootPtr (FileSystemRoot root) = withForeignPtr root+++touchFSRoot :: FileSystemRoot -> IO ()+touchFSRoot (FileSystemRoot root) = touchForeignPtr root+++getRootFS :: FileSystemRoot -> IO FileSystem+getRootFS root+ = withFSRootPtr root $ \ rootPtr ->+ -- 實際には root が生きてゐる限り fs は死なないのだが、念の爲。+ wrapFS (touchFSRoot root) =<< _root_fs rootPtr++-- |@'getFileLength' path@ returns the length of file @path@.+getFileLength :: MonadFS m => FilePath -> m Integer+getFileLength path+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ lenPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _file_length lenPtr rootPtr pathPtr poolPtr+ return . toInteger =<< peek lenPtr++-- |@'getFileMD5' path@ returns the MD5 checksum of file @path@. If+-- the filesystem does not have a prerecorded checksum for @path@, it+-- doesn't calculate a checksum dynamically, just puts all 0's into+-- the resulting digest. (By convention, the all-zero checksum is+-- considered to match any checksum.)+getFileMD5 :: MonadFS m => FilePath -> m [Word8]+getFileMD5 path+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ allocaArray md5Len $ \ bufPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _file_md5_checksum bufPtr rootPtr pathPtr poolPtr+ return . map fromIntegral =<< peekArray md5Len bufPtr+ where+ md5Len = (#const APR_MD5_DIGESTSIZE)+++-- |@'getFileContents' path@ returns the content of file @path@.+--+-- If this is a non-transactional monad (that is, a monad whose+-- 'isTransaction' returns 'Prelude.False'), it reads the content+-- /lazilly/. But if this is a transactional monad, 'getFileContents'+-- does the operation /strictly/: I mean it loads the entire file onto+-- the memory! This is because @svn_fs_file_contents()@ in the+-- libsvn_fs doesn't guarantee, when we are in a transaction, that we+-- can progressively read a file which is suddenly modified in the+-- same transaction during the progressive reading.+--+-- I think 'getFileContents' might have to return+-- @['Data.Word.Word8']@ instead of 'Prelude.String' because every+-- files in filesystem should be considered binary. Yes,+-- 'Prelude.readFile' also returns 'Prelude.String' but this is an+-- immature part of Haskell. I wish someday the GHC gets more clear+-- distinction between binary data and an Unicode string, then I+-- change the form of 'getFileContents' alike.+getFileContents :: MonadFS m => FilePath -> m String+getFileContents path+ = liftM L8.unpack $ getFileContentsLBS path+++-- |@'getFileContentsLBS'@ does the same thing as 'getFileContents'+-- but returns 'Data.ByteString.Base.LazyByteString' instead.+getFileContentsLBS :: MonadFS m => FilePath -> m LazyByteString+getFileContentsLBS path+ = do root <- getRoot+ isTxn <- isTransaction+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ ioPtrPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ (svnErr $ _file_contents ioPtrPtr rootPtr pathPtr poolPtr)+ >> peek ioPtrPtr+ >>= wrapStream (touchPool pool)+ >>= (if isTxn then+ sStrictReadLBS+ else+ sReadLBS)++-- |@'getNodePropList' path@ returns the property list of @path@ in a+-- revision or transaction.+getNodePropList :: MonadFS m => FilePath -> m [(String, String)]+getNodePropList path+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ hashPtrPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _node_proplist hashPtrPtr rootPtr pathPtr poolPtr+ hash <- wrapHash (touchPool pool) =<< peek hashPtrPtr+ mapHash' (\ (n, v)+ -> peekSvnString v+ >>=+ return . ((,) n) . B8.unpack) hash++-- |@'getNodeProp' path propName@ returns the value of the property+-- named @propName@ of @path@ in a revision or transaction.+getNodeProp :: MonadFS m => FilePath -> String -> m (Maybe String)+getNodeProp path name+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ valPtrPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withCString name $ \ namePtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _node_prop valPtrPtr rootPtr pathPtr namePtr poolPtr+ prop <- peekSvnString' =<< peek valPtrPtr+ -- prop は pool の中から讀み取られるので、それが濟+ -- むまで pool が死んでは困る。+ touchPool pool+ return $ fmap B8.unpack prop++-- |@'getDirEntries' path@ returns a list containing the entries of+-- the directory at @path@ in a revision or transaction.+getDirEntries :: MonadFS m => FilePath -> m [DirEntry]+getDirEntries path+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ hashPtrPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _dir_entries hashPtrPtr rootPtr pathPtr poolPtr+ peek hashPtrPtr+ >>= wrapHash (touchFSRoot root >> touchPool pool)+ >>= hashToValues++-- |@'getPathsChanged'@ returns a list containing descriptions of the+-- paths changed under a revision or transaction.+getPathsChanged :: MonadFS m => m [(FilePath, PathChange)]+getPathsChanged+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ hashPtrPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _paths_changed hashPtrPtr rootPtr poolPtr+ peek hashPtrPtr+ >>= wrapHash (touchFSRoot root >> touchPool pool)+ >>= hashToPairs++-- |@'checkPath' path@ returns a 'Subversion.Types.NodeKind' for+-- @path@. Unlike most other actions, 'checkPath' doesn't throw an+-- error even if the @path@ doesn't point to an existent node: in that+-- case it just returns 'Subversion.Types.NoNode'.+checkPath :: MonadFS m => FilePath -> m NodeKind+checkPath path+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ kindPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _check_path kindPtr rootPtr pathPtr poolPtr+ return . unmarshalNodeKind =<< peek kindPtr++-- |@'isDirectory' path@ returns 'Prelude.True' iff the @path@ points+-- to a directory in a revision or transaction. It returns+-- 'Prelude.False' for inexistent path.+isDirectory :: MonadFS m => FilePath -> m Bool+isDirectory path+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ boolPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _is_dir boolPtr rootPtr pathPtr poolPtr+ return . unmarshalBool =<< peek boolPtr++-- |@'isFile' path@ returns 'Prelude.True' iff the @path@ points to a+-- file in a revision or transaction. It returns 'Prelude.False' for+-- inexistent path.+isFile :: MonadFS m => FilePath -> m Bool+isFile path+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ boolPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _is_file boolPtr rootPtr pathPtr poolPtr+ return . unmarshalBool =<< peek boolPtr
+ Subversion/FileSystem/Transaction.hsc view
@@ -0,0 +1,338 @@+{- -*- haskell -*- -}++-- #prune++-- |An interface to functions that work on a filesystem transaction.++module Subversion.FileSystem.Transaction+ ( -- * Type + Txn++ , Transaction -- private+ , SVN_FS_TXN_T -- private++ , wrapTxn -- private+ , withTxnPtr -- private+ , runTxn -- private++ , abortTxn -- private+ , getTransactionRoot -- private++ -- * Accessing transaction property+ , getTxnProp+ , getTxnPropList+ , setTxnProp++ -- * Changing content of file+ , applyText+ , applyTextLBS++ -- * Changing node property+ , setNodeProp++ -- * Creating, deleting and copying entry+ , makeFile+ , makeDirectory++ , deleteEntry++ , copyEntry+ )+ where++import Control.Monad.Reader+import Control.Monad+import Data.ByteString.Base+import qualified Data.ByteString.Char8 as B8+import qualified Data.ByteString.Lazy.Char8 as L8+import Foreign.C.String+import Foreign.ForeignPtr+import Foreign.Ptr+import Foreign.Marshal.Alloc+import Foreign.Storable+import GHC.ForeignPtr as GF+import Subversion.Error+import Subversion.FileSystem.Revision+import Subversion.FileSystem.Root+import Subversion.Hash+import Subversion.Pool+import Subversion.Stream+import Subversion.String+import Subversion.Types++{- Monad Txn ----------------------------------------------------------------- -}++data TxnContext = TxnContext {+ ctxTxn :: Transaction+ , ctxRoot :: FileSystemRoot+ }++-- |@'Txn' a@ is a FS monad which reads and updates data in filesystem+-- and finally returns @a@. See 'Subversion.FileSystem.Root.MonadFS'.+newtype Txn a = Txn { unTxn :: ReaderT TxnContext IO a }++instance Functor Txn where+ fmap f c = Txn (fmap f (unTxn c))++instance Monad Txn where+ c >>= f = Txn (unTxn c >>= unTxn . f)+ return = Txn . return+ fail = Txn . fail++instance MonadFS Txn where+ getRoot = Txn (ask >>= return . ctxRoot)+ unsafeIOToFS a = Txn (liftIO a)+ isTransaction = Txn (return True)+++getTxn :: Txn Transaction+getTxn = Txn (ask >>= return . ctxTxn)+++{- functions and types ------------------------------------------------------- -}++newtype Transaction = Transaction (ForeignPtr SVN_FS_TXN_T)+data SVN_FS_TXN_T+++foreign import ccall "svn_fs_abort_txn"+ _abort_txn :: Ptr SVN_FS_TXN_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall "svn_fs_txn_root"+ _txn_root :: Ptr (Ptr SVN_FS_ROOT_T) -> Ptr SVN_FS_TXN_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_txn_prop"+ _txn_prop :: Ptr (Ptr SVN_STRING_T) -> Ptr SVN_FS_TXN_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_txn_proplist"+ _txn_proplist :: Ptr (Ptr APR_HASH_T) -> Ptr SVN_FS_TXN_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_change_txn_prop"+ _change_txn_prop :: Ptr SVN_FS_TXN_T -> CString -> Ptr SVN_STRING_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_change_node_prop"+ _change_node_prop :: Ptr SVN_FS_ROOT_T -> CString -> CString -> Ptr SVN_STRING_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_apply_text"+ _apply_text :: Ptr (Ptr SVN_STREAM_T) -> Ptr SVN_FS_ROOT_T -> CString -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_make_file"+ _make_file :: Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_make_dir"+ _make_dir :: Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_delete"+ _delete :: Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_fs_copy"+ _copy :: Ptr SVN_FS_ROOT_T -> CString -> Ptr SVN_FS_ROOT_T -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)+++wrapTxn :: IO () -> Ptr SVN_FS_TXN_T -> IO Transaction+wrapTxn finalizer txnPtr+ = do txn <- newForeignPtr_ txnPtr+ GF.addForeignPtrConcFinalizer txn finalizer+ return $ Transaction txn+++touchTxn :: Transaction -> IO ()+touchTxn (Transaction txn) = touchForeignPtr txn+++withTxnPtr :: Transaction -> (Ptr SVN_FS_TXN_T -> IO a) -> IO a+withTxnPtr (Transaction txn) = withForeignPtr txn+++runTxn :: Txn a -> Transaction -> IO a+runTxn c txn+ = do root <- getTransactionRoot txn++ -- We've got the txn root so we can run the Txn monad.+ let ctx = TxnContext {+ ctxTxn = txn+ , ctxRoot = root+ }++ runReaderT (unTxn c) ctx+++abortTxn :: Transaction -> IO ()+abortTxn txn+ = do pool <- newPool+ withTxnPtr txn $ \ txnPtr ->+ withPoolPtr pool $ \ poolPtr ->+ svnErr $ _abort_txn txnPtr poolPtr+++getTransactionRoot :: Transaction -> IO FileSystemRoot+getTransactionRoot txn+ = do pool <- newPool+ alloca $ \ rootPtrPtr ->+ withTxnPtr txn $ \ txnPtr ->+ withPoolPtr pool $ \ poolPtr ->+ (svnErr $ _txn_root rootPtrPtr txnPtr poolPtr)+ >> peek rootPtrPtr+ >>= (wrapFSRoot $+ -- root は pool にも txn にも依存する。+ touchPool pool >> touchTxn txn)++-- |@'getTxnProp' propName@ returns the value of the property named+-- @propName@ on the transaction.+getTxnProp :: String -> Txn (Maybe String)+getTxnProp name+ = do txn <- getTxn+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ valPtrPtr ->+ withTxnPtr txn $ \ txnPtr ->+ withCString name $ \ namePtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _txn_prop valPtrPtr txnPtr namePtr poolPtr+ prop <- peekSvnString' =<< peek valPtrPtr+ -- prop は pool の中から讀み取られるので、それが濟+ -- むまでは pool が死んでは困る。+ touchPool pool+ return $ fmap B8.unpack prop++-- |@'getTxnPropList'@ returns the entire property list on the+-- transaction.+getTxnPropList :: Txn [(String, String)]+getTxnPropList + = do txn <- getTxn+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ hashPtrPtr ->+ withTxnPtr txn $ \ txnPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _txn_proplist hashPtrPtr txnPtr poolPtr+ hash <- wrapHash (touchPool pool) =<< peek hashPtrPtr+ mapHash' (\ (n, v)+ -> peekSvnString v+ >>=+ return . ((,) n) . B8.unpack) hash++-- |@'setTxnProp' propName propValue@ changes, adds or deletes a+-- property on the transaction.+setTxnProp :: String -> Maybe String -> Txn ()+setTxnProp name valStr+ = do txn <- getTxn+ pool <- unsafeIOToFS newPool+ let value = fmap B8.pack valStr+ unsafeIOToFS $ withTxnPtr txn $ \ txnPtr ->+ withCString name $ \ namePtr ->+ withSvnString' value $ \ valuePtr ->+ withPoolPtr pool $ \ poolPtr ->+ svnErr $ _change_txn_prop txnPtr namePtr valuePtr poolPtr++-- |@'setNodeProp' fpath propName propValue@ changes, adds or deletes+-- a property named @propName@ on file @fpath@.+setNodeProp :: FilePath -> String -> Maybe String -> Txn ()+setNodeProp path name valStr+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ let value = fmap B8.pack valStr+ unsafeIOToFS $ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withCString name $ \ namePtr ->+ withSvnString' value $ \ valuePtr ->+ withPoolPtr pool $ \ poolPtr ->+ svnErr $ _change_node_prop rootPtr pathPtr namePtr valuePtr poolPtr+++-- |@'applyText'@ replaces the content of file.+applyText+ :: FilePath -- ^ The file to be replaced. If it does not exist+ -- in the transaction, 'applyText' throws an+ -- error. That is, you can't use this action to+ -- create new files; use 'makeFile' to create an+ -- empty file first.+ -> Maybe String -- ^ The hex MD5 digest for the new content. It is+ -- ignored if 'Prelude.Nothing', but if not+ -- 'Prelude.Nothing', it must match the checksum+ -- of the content; if it doesn't, 'applyText'+ -- throws an error.+ -> String -- ^ The new content. + --+ -- This argument is currently a 'Prelude.String'+ -- but someday it may be changed to+ -- @['Data.Word.Word8']@ or something alike. See+ -- 'Subversion.FileSystem.Root.getFileContents'.+ -> Txn ()+applyText path resultMD5 contents+ = applyTextLBS path resultMD5 (L8.pack contents)++-- |@'applyTextLBS'@ does the same thing as 'applyText' but takes+-- 'Data.ByteString.Base.LazyByteString' instead.+applyTextLBS :: FilePath -> Maybe String -> LazyByteString -> Txn ()+applyTextLBS path resultMD5 contents+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ alloca $ \ ioPtrPtr ->+ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withCString' resultMD5 $ \ resultMD5Ptr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _apply_text ioPtrPtr rootPtr pathPtr resultMD5Ptr poolPtr+ io <- wrapStream (touchPool pool) =<< peek ioPtrPtr+ sWriteLBS io contents+ sClose io+ where+ withCString' :: Maybe String -> (CString -> IO a) -> IO a+ withCString' Nothing f = f nullPtr+ withCString' (Just str) f = withCString str f++-- |@'makeFile' fpath@ creates a new file named @fpath@. The initial+-- content of file is the empty string, and it has no properties.+makeFile :: FilePath -> Txn ()+makeFile path+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ svnErr $ _make_file rootPtr pathPtr poolPtr++-- |@'makeDirectory' fpath@ creates a new directory named @fpath@. The+-- new directory has no entries, and no properties.+makeDirectory :: FilePath -> Txn ()+makeDirectory path+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ svnErr $ _make_dir rootPtr pathPtr poolPtr++-- |@'deleteEntry' fpath@ delete the node named @fpath@ in the+-- transaction. If the node being deleted is a directory, its contents+-- will be deleted recursively.+--+-- If the @fpath@ is missing from the transaction, 'deleteEntry'+-- throws an error.+--+-- Attempting to remove the root directory also results in an error,+-- even if the directory is empty.+deleteEntry :: FilePath -> Txn ()+deleteEntry path+ = do root <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ withFSRootPtr root $ \ rootPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ svnErr $ _delete rootPtr pathPtr poolPtr++-- |@'copyEntry' fromRevNum fromPath toPath@ creates a copy of file+-- @fromPath@ in a revision @fromRevNum@ named @toPath@ in the+-- transaction.+copyEntry :: RevNum -> FilePath -> FilePath -> Txn ()+copyEntry fromRevNum fromPath toPath+ = do toRoot <- getRoot+ fs <- unsafeIOToFS $ getRootFS toRoot+ unsafeIOToFS $ withRevision fs fromRevNum+ $ do fromRoot <- getRoot+ pool <- unsafeIOToFS newPool+ unsafeIOToFS $ withFSRootPtr fromRoot $ \ fromRootPtr ->+ withCString fromPath $ \ fromPathPtr ->+ withFSRootPtr toRoot $ \ toRootPtr ->+ withCString toPath $ \ toPathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ svnErr $ _copy fromRootPtr fromPathPtr toRootPtr toPathPtr poolPtr
+ Subversion/Hash.hsc view
@@ -0,0 +1,246 @@+#include "HsSVN.h"++module Subversion.Hash+ ( Hash+ , HashValue(..)+ , APR_HASH_T++ , withHashPtr+ , unsafeHashToPtr+ , touchHash+ , wrapHash++ , new+ , update+ , delete+ , lookup++ , pairsToHash+ , hashToPairs++ , hashToValues++ , mapHash+ , mapHash'+ )+ where++import Control.Monad+import Foreign.C.String+import Foreign.C.Types+import Foreign.ForeignPtr+import Foreign.Marshal.Alloc+import Foreign.Marshal.Utils hiding (new)+import Foreign.Ptr+import Foreign.Storable+import qualified GHC.ForeignPtr as GF+import Prelude hiding (lookup)+import Subversion.Pool+import Subversion.Types+import System.IO.Unsafe+++newtype Hash a = Hash (ForeignPtr APR_HASH_T)+data APR_HASH_T++newtype HashIndex a = HashIndex (ForeignPtr APR_HASH_INDEX_T)+data APR_HASH_INDEX_T+++mallocStringForeignPtr :: String -> IO (ForeignPtr CChar)+mallocStringForeignPtr str+ = withCStringLen str $ \ (strPtr, len) ->+ do strFPtr <- mallocForeignPtrBytes $ len + 1+ copyBytes (unsafeForeignPtrToPtr strFPtr) strPtr len+ pokeByteOff (unsafeForeignPtrToPtr strFPtr) len '\0'+ return strFPtr+++class HashValue a where+ marshal :: a -> IO (ForeignPtr ())+ unmarshal :: IO () -> Ptr () -> IO a++instance HashValue String where+ marshal str+ = mallocStringForeignPtr str >>= return . castForeignPtr++ unmarshal finalizer strPtr+ = do str <- peekCString (castPtr strPtr)+ finalizer+ return str+++foreign import ccall unsafe "apr_hash_make"+ _make :: Ptr APR_POOL_T -> IO (Ptr APR_HASH_T)++foreign import ccall unsafe "apr_hash_set"+ _set :: Ptr APR_HASH_T -> Ptr () -> APR_SSIZE_T -> Ptr () -> IO ()++foreign import ccall unsafe "apr_hash_get"+ _get :: Ptr APR_HASH_T -> Ptr () -> APR_SSIZE_T -> IO (Ptr ())++foreign import ccall unsafe "apr_hash_first"+ _first :: Ptr APR_POOL_T -> Ptr APR_HASH_T -> IO (Ptr APR_HASH_INDEX_T)++foreign import ccall unsafe "apr_hash_this"+ _this :: Ptr APR_HASH_INDEX_T -> Ptr (Ptr ()) -> Ptr APR_SSIZE_T -> Ptr (Ptr ()) -> IO ()++foreign import ccall unsafe "apr_hash_next"+ _next :: Ptr APR_HASH_INDEX_T -> IO (Ptr APR_HASH_INDEX_T)+++wrapHash :: IO () -> Ptr APR_HASH_T -> IO (Hash a)+wrapHash finalizer hashPtr+ = do hash <- newForeignPtr_ hashPtr+ GF.addForeignPtrConcFinalizer hash finalizer+ return $ Hash hash+++withHashPtr :: Hash a -> (Ptr APR_HASH_T -> IO b) -> IO b+withHashPtr (Hash hash) = withForeignPtr hash+++unsafeHashToPtr :: Hash a -> Ptr APR_HASH_T+unsafeHashToPtr (Hash hash) = unsafeForeignPtrToPtr hash+++touchHash :: Hash a -> IO ()+touchHash (Hash hash) = touchForeignPtr hash+++wrapHashIdx :: IO () -> Ptr APR_HASH_INDEX_T -> IO (HashIndex a)+wrapHashIdx finalizer idxPtr+ = do idx <- newForeignPtr_ idxPtr+ GF.addForeignPtrConcFinalizer idx finalizer+ return $ HashIndex idx+++withHashIdxPtr :: HashIndex a -> (Ptr APR_HASH_INDEX_T -> IO b) -> IO b+withHashIdxPtr (HashIndex idx) = withForeignPtr idx+++touchHashIdx :: HashIndex a -> IO ()+touchHashIdx (HashIndex idx) = touchForeignPtr idx+++new :: HashValue a => IO (Hash a)+new = do pool <- newPool+ withPoolPtr pool $ \ poolPtr ->+ _make poolPtr >>= wrapHash (touchPool pool)++-- 一旦 Hash に入れた値は、Hash 自体が解放されるまでは解放されなくなる+-- 事に注意。それがまずいのであれば、Hash 自体に Map (Ptr ())+-- (ForeignPtr ()) を持たせて、その Map を同時に管理しなければならない。+-- 面倒だ。+update :: HashValue a => Hash a -> String -> a -> IO ()+update (Hash hash) key value+ = withForeignPtr hash $ \ hashPtr ->+ do keyFPtr <- mallocStringForeignPtr key+ valueFPtr <- marshal value+ _set hashPtr+ (castPtr $ unsafeForeignPtrToPtr keyFPtr)+ (#const APR_HASH_KEY_STRING)+ (unsafeForeignPtrToPtr valueFPtr)+ -- hash よりも key 及び value が先に解放されては困る。+ GF.addForeignPtrConcFinalizer hash+ $ do touchForeignPtr keyFPtr+ touchForeignPtr valueFPtr+++delete :: Hash a -> String -> IO ()+delete hash key+ = withHashPtr hash $ \ hashPtr ->+ withCStringLen key $ \ (keyPtr, keyLen) ->+ _set hashPtr (castPtr keyPtr) (fromIntegral keyLen) nullPtr+++lookup :: HashValue a => Hash a -> String -> IO (Maybe a)+lookup hash key+ = withHashPtr hash $ \ hashPtr ->+ withCStringLen key $ \ (keyPtr, keyLen) ->+ do valuePtr <- _get hashPtr (castPtr keyPtr) (fromIntegral keyLen)+ if valuePtr == nullPtr then+ return Nothing+ else+ -- valuePtr は hash の解放と同時に解放され得るのだが、+ -- unmarshal する前にそれが起きては困る。+ unmarshal (touchHash hash) valuePtr+ >>= return . Just+++getFirst :: Hash a -> IO (Maybe (HashIndex a))+getFirst hash+ = do pool <- newPool+ withPoolPtr pool $ \ poolPtr ->+ withHashPtr hash $ \ hashPtr ->+ do idxPtr <- _first poolPtr hashPtr+ if idxPtr == nullPtr then+ return Nothing+ else+ liftM Just $ wrapHashIdx (touchPool pool) idxPtr+++getThis :: HashValue a => HashIndex a -> IO (String, a)+getThis idx+ = do (key, valPtr) <- getThis' idx+ val <- unmarshal (touchHashIdx idx) (castPtr valPtr)+ return (key, val)+++getThis' :: HashIndex a -> IO (String, Ptr a)+getThis' idx+ = withHashIdxPtr idx $ \ idxPtr ->+ alloca $ \ keyPtrPtr ->+ alloca $ \ keyLenPtr ->+ alloca $ \ valPtrPtr ->+ do _this idxPtr keyPtrPtr keyLenPtr valPtrPtr+ keyPtr <- liftM castPtr (peek keyPtrPtr)+ keyLen <- liftM fromIntegral (peek keyLenPtr)+ key <- peekCStringLen (keyPtr, keyLen)+ valPtr <- peek valPtrPtr+ return (key, castPtr valPtr)+++getNext :: HashIndex a -> IO (Maybe (HashIndex a))+getNext idx+ = withHashIdxPtr idx $ \ idxPtr ->+ do idxPtr' <- _next idxPtr+ if idxPtr' == nullPtr then+ return Nothing+ else+ liftM Just $ wrapHashIdx (touchHashIdx idx) idxPtr'+ ++pairsToHash :: HashValue a => [(String, a)] -> IO (Hash a)+pairsToHash xs+ = do hash <- new+ mapM_ (uncurry $ update hash) xs+ return hash+++hashToPairs :: HashValue a => Hash a -> IO [(String, a)]+hashToPairs = mapHash (return . id)+++hashToValues :: HashValue a => Hash a -> IO [a]+hashToValues = mapHash (return . snd)+++mapHash :: HashValue a => ((String, a) -> IO b) -> Hash a -> IO [b]+mapHash f hash = getFirst hash >>= loop+ where+ loop Nothing = return []+ loop (Just idx) = do x <- f =<< getThis idx+ xs <- unsafeInterleaveIO $+ (getNext idx >>= loop)+ return (x:xs)+++mapHash' :: ((String, Ptr a) -> IO b) -> Hash a -> IO [b]+mapHash' f hash = getFirst hash >>= loop+ where+ loop Nothing = return []+ loop (Just idx) = do x <- f =<< getThis' idx+ xs <- unsafeInterleaveIO $+ (getNext idx >>= loop)+ return (x:xs)
+ Subversion/Pool.hsc view
@@ -0,0 +1,35 @@+module Subversion.Pool+ ( Pool+ , APR_POOL_T+ , newPool+ , withPoolPtr+ , touchPool+ )+ where++import Foreign hiding (Pool, newPool)+++newtype Pool = Pool (ForeignPtr APR_POOL_T)+data APR_POOL_T+++foreign import ccall unsafe "HsSVN_svn_pool_create"+ _create :: Ptr APR_POOL_T -> IO (Ptr APR_POOL_T)++foreign import ccall unsafe "&HsSVN_svn_pool_destroy"+ _destroy :: FunPtr (Ptr APR_POOL_T -> IO ())+++newPool :: IO Pool+newPool = _create nullPtr+ >>= newForeignPtr _destroy+ >>= return . Pool+++withPoolPtr :: Pool -> (Ptr APR_POOL_T -> IO a) -> IO a+withPoolPtr (Pool pool) = withForeignPtr pool+++touchPool :: Pool -> IO ()+touchPool (Pool pool) = touchForeignPtr pool
+ Subversion/Repository.hsc view
@@ -0,0 +1,234 @@+{- -*- haskell -*- -}++-- |An interface to repository, which is built on top of the+-- filesystem.++module Subversion.Repository+ ( Repository++ , openRepository+ , createRepository+ , deleteRepository++ , getRepositoryFS++ , doReposTxn+ )+ where++import Control.Exception+import Control.Monad+import Data.Maybe+import Foreign.C.String+import Foreign.C.Types+import Foreign.ForeignPtr+import Foreign.Ptr+import Foreign.Marshal.Alloc+import Foreign.Storable+import GHC.ForeignPtr as GF+import Subversion.Config+import Subversion.FileSystem+import Subversion.FileSystem.Transaction+import Subversion.Hash+import Subversion.Error+import Subversion.Pool+import Subversion.Types++-- |@'Repository'@ is an opaque object representing a Subversion+-- repository.+newtype Repository = Repository (ForeignPtr SVN_REPOS_T)+data SVN_REPOS_T+++foreign import ccall unsafe "svn_repos_open"+ _open :: Ptr (Ptr SVN_REPOS_T) -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_repos_create"+ _create :: Ptr (Ptr SVN_REPOS_T) -> CString -> Ptr CChar -> Ptr CChar -> Ptr APR_HASH_T -> Ptr APR_HASH_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_repos_delete"+ _delete :: CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_repos_fs"+ _fs :: Ptr SVN_REPOS_T -> IO (Ptr SVN_FS_T)++foreign import ccall unsafe "svn_repos_fs_begin_txn_for_commit"+ _fs_begin_txn_for_commit :: Ptr (Ptr SVN_FS_TXN_T) -> Ptr SVN_REPOS_T -> SVN_REVNUM_T -> CString -> CString -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_repos_fs_commit_txn"+ _fs_commit_txn :: Ptr CString -> Ptr SVN_REPOS_T -> Ptr SVN_REVNUM_T -> Ptr SVN_FS_TXN_T -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)+++wrapRepos :: IO () -> Ptr SVN_REPOS_T -> IO Repository+wrapRepos finalizer reposPtr+ = do repos <- newForeignPtr_ reposPtr+ GF.addForeignPtrConcFinalizer repos finalizer+ return $ Repository repos+++withReposPtr :: Repository -> (Ptr SVN_REPOS_T -> IO a) -> IO a+withReposPtr (Repository repos) = withForeignPtr repos+++touchRepos :: Repository -> IO ()+touchRepos (Repository repos) = touchForeignPtr repos++-- |@'openRepository' fpath@ opens a Subversion repository at @fpath@.+--+-- It acquires a shared lock on the repository, and the lock will be+-- removed by the garbage collector. If an exclusive lock is present,+-- this blocks until it's gone.+openRepository :: FilePath -> IO Repository+openRepository path+ = do pool <- newPool+ alloca $ \ reposPtrPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _open reposPtrPtr pathPtr poolPtr+ wrapRepos (touchPool pool) =<< peek reposPtrPtr++-- |@'createRepository'@ creates a new Subversion repository, building+-- the necessary directory structure, creating filesystem, and so on.+createRepository+ :: FilePath -- ^ Where to create the repository.+ -> [(String, Config)] -- ^ A list of @(categoryName, config)@+ -- tuples which represents a client+ -- configuration. It may be an empty list.+ -> [(String, String)] -- ^ This list is passed to the+ -- filesystem. See+ -- 'Subversion.FileSystem.createFileSystem'.+ -> IO Repository+createRepository path configPairs fsConfigPairs+ = do pool <- newPool+ alloca $ \ reposPtrPtr ->+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do config <- pairsToHash configPairs+ fsConfig <- pairsToHash fsConfigPairs+ svnErr (_create+ reposPtrPtr+ pathPtr+ nullPtr+ nullPtr+ (unsafeHashToPtr config)+ (unsafeHashToPtr fsConfig)+ poolPtr)++ repos <- wrapRepos (touchPool pool) =<< peek reposPtrPtr++ -- config と fsConfig には、repos が死ぬまでは生き+ -- てゐて慾しい。+ GF.addForeignPtrConcFinalizer (case repos of Repository x -> x)+ $ (touchHash config >> touchHash fsConfig)++ return repos++-- |@'deleteRepository' fpath@ destroys the Subversion repository at+-- @fpath@.+deleteRepository :: FilePath -> IO ()+deleteRepository path+ = do pool <- newPool+ withCString path $ \ pathPtr ->+ withPoolPtr pool $ \ poolPtr ->+ svnErr $ _delete pathPtr poolPtr++-- |@'getRepositoryFS' repos@ returns the filesystem associated with+-- repository @repos@.+getRepositoryFS :: Repository -> IO FileSystem+getRepositoryFS repos+ = withReposPtr repos $ \ reposPtr ->+ -- svn_fs_t* より先に svn_repos_t* が解放されては困る+ _fs reposPtr >>= wrapFS (touchRepos repos)+++beginTxn :: Repository -> RevNum -> String -> Maybe String -> IO Transaction+beginTxn repos revNum author logMsg+ = do pool <- newPool+ alloca $ \ txnPtrPtr ->+ withReposPtr repos $ \ reposPtr ->+ withCString author $ \ authorPtr ->+ withCString' logMsg $ \ logMsgPtr ->+ withPoolPtr pool $ \ poolPtr ->+ (svnErr $+ _fs_begin_txn_for_commit+ txnPtrPtr+ reposPtr+ (fromIntegral revNum)+ authorPtr+ logMsgPtr+ poolPtr)+ >> peek txnPtrPtr+ >>= (wrapTxn $+ -- txn は pool にも repos にも依存する。+ touchPool pool >> touchRepos repos)+ where+ withCString' :: Maybe String -> (CString -> IO a) -> IO a+ withCString' Nothing f = f nullPtr+ withCString' (Just str) f = withCString str f+ ++commitTxn :: Repository -> Transaction -> IO (Either FilePath RevNum)+commitTxn repos txn+ = do pool <- newPool+ alloca $ \ conflictPathPtrPtr ->+ withReposPtr repos $ \ reposPtr ->+ alloca $ \ newRevPtr ->+ withTxnPtr txn $ \ txnPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do err <- wrapSvnError =<< (_fs_commit_txn+ conflictPathPtrPtr+ reposPtr+ newRevPtr+ txnPtr+ poolPtr)+ case err of+ Nothing+ -> liftM (Right . fromIntegral) (peek newRevPtr)++ Just e+ -> if svnErrCode e == FsConflict then+ return . Left =<< peekCString =<< peek conflictPathPtrPtr+ else+ throwSvnErr e++-- |@'doReposTxn'@ tries to do the transaction. If it succeeds+-- 'doReposTxn' automatically commits it, but if it throws an+-- exception 'doReposTxn' automatically cancels it and rethrow the+-- exception.+--+-- Because conflicts tend to occur more frequently than other errors,+-- they aren't reported as an exception.+doReposTxn+ :: Repository -- ^ The repository.+ -> RevNum -- ^ An existing revision number which the+ -- transaction bases on.+ -> String -- ^ The author name to be recorded as a+ -- transaction property.+ -> Maybe String -- ^ The log message to be recorded as a+ -- transaction property. This value may be+ -- 'Prelude.Nothing' if the message is not yet+ -- available. The caller will need to attach one+ -- to the transaction at a later time.+ -> Txn () -- ^ The transaction to be done.+ -> IO (Either FilePath RevNum) -- ^ The result is whether+ -- @'Prelude.Left' conflictPath@+ -- (if it conflicted) or+ -- @'Prelude.Right' newRevNum@ (if+ -- it didn't).+doReposTxn repos revNum author logMsg c+ = do txn <- beginTxn repos revNum author logMsg+ handle (cleanUp txn) (tryTxn txn)+ where+ cleanUp :: Transaction -> Exception -> IO a+ cleanUp txn exn+ = abortTxn txn+ >>+ throwIO exn++ tryTxn :: Transaction -> IO (Either FilePath Int)+ tryTxn txn+ = do runTxn c txn+ + -- Good. We've got no exceptions during the computation+ -- of Txn (). Now let us commit the transaction.+ commitTxn repos txn
+ Subversion/Stream.hsc view
@@ -0,0 +1,164 @@+module Subversion.Stream+ ( Stream+ , SVN_STREAM_T++ , wrapStream+ , withStreamPtr++ , getEmptyStream+ , getStreamForStdOut++ , sRead+ , sReadBS+ , sReadLBS++ , sStrictRead+ , sStrictReadLBS++ , sWrite+ , sWriteBS+ , sWriteLBS++ , sClose+ )+ where++import Control.Monad+import Data.ByteString.Base+import qualified Data.ByteString.Char8 as B8+import qualified Data.ByteString.Lazy.Char8 as L8+import Foreign.C.Types+import Foreign.ForeignPtr+import Foreign.Ptr+import Foreign.Marshal.Alloc+import Foreign.Storable+import GHC.ForeignPtr as GF+import Subversion.Error+import Subversion.Pool+import Subversion.Types+import System.IO.Unsafe+++newtype Stream = Stream (ForeignPtr SVN_STREAM_T)+data SVN_STREAM_T+++foreign import ccall unsafe "svn_stream_empty"+ _empty :: Ptr APR_POOL_T -> IO (Ptr SVN_STREAM_T)++foreign import ccall unsafe "svn_stream_for_stdout"+ _for_stdout :: Ptr (Ptr SVN_STREAM_T) -> Ptr APR_POOL_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_stream_read"+ _read :: Ptr SVN_STREAM_T -> Ptr CChar -> Ptr APR_SIZE_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_stream_write"+ _write :: Ptr SVN_STREAM_T -> Ptr CChar -> Ptr APR_SIZE_T -> IO (Ptr SVN_ERROR_T)++foreign import ccall unsafe "svn_stream_close"+ _close :: Ptr SVN_STREAM_T -> IO (Ptr SVN_ERROR_T)+++wrapStream :: IO () -> Ptr SVN_STREAM_T -> IO Stream+wrapStream finalizer ioPtr+ = do io <- newForeignPtr_ ioPtr+ GF.addForeignPtrConcFinalizer io finalizer+ return $ Stream io+++withStreamPtr :: Stream -> (Ptr SVN_STREAM_T -> IO a) -> IO a+withStreamPtr (Stream io) = withForeignPtr io+++getEmptyStream :: IO Stream+getEmptyStream + = do pool <- newPool+ withPoolPtr pool $ \ poolPtr ->+ wrapStream (touchPool pool) =<< _empty poolPtr+++getStreamForStdOut :: IO Stream+getStreamForStdOut+ = do pool <- newPool+ alloca $ \ ioPtrPtr ->+ withPoolPtr pool $ \ poolPtr ->+ do svnErr $ _for_stdout ioPtrPtr poolPtr+ wrapStream (touchPool pool) =<< peek ioPtrPtr+++sRead :: Stream -> IO String+sRead io+ = liftM L8.unpack $ sReadLBS io+++sStrictRead :: Stream -> IO String+sStrictRead io+ = liftM L8.unpack $ sStrictReadLBS io+++sReadBS :: Stream -> Int -> IO ByteString+sReadBS io maxLen+ = withStreamPtr io $ \ ioPtr ->+ createAndTrim maxLen $ \ bufPtr ->+ alloca $ \ bufLenPtr ->+ do poke bufLenPtr (fromIntegral maxLen)+ svnErr $ _read ioPtr (castPtr bufPtr) bufLenPtr+ liftM fromIntegral $ peek bufLenPtr+++sReadLBS :: Stream -> IO LazyByteString+sReadLBS io = lazyRead >>= return . LPS+ where+ chunkSize = 32 * 1024++ lazyRead = unsafeInterleaveIO loop++ loop = do bs <- sReadBS io chunkSize+ if B8.null bs then+ -- reached EOF+ return []+ else+ do bss <- lazyRead+ return (bs:bss)+++sStrictReadLBS :: Stream -> IO LazyByteString+sStrictReadLBS io = strictRead >>= return . LPS+ where+ chunkSize = 32 * 1024++ strictRead = unsafeInterleaveIO loop++ loop = do bs <- sReadBS io chunkSize+ if B8.null bs then+ -- reached EOF+ return []+ else+ do bss <- strictRead+ return (bs:bss)++++sWrite :: Stream -> String -> IO ()+sWrite io str+ = sWriteLBS io (L8.pack str)+++sWriteBS :: Stream -> ByteString -> IO ()+sWriteBS io str+ = withStreamPtr io $ \ ioPtr ->+ unsafeUseAsCStringLen str $ \ (strPtr, strLen) ->+ alloca $ \ strLenPtr ->+ do poke strLenPtr (fromIntegral strLen)+ svnErr $ _write ioPtr strPtr strLenPtr+++sWriteLBS :: Stream -> LazyByteString -> IO ()+sWriteLBS io (LPS chunks)+ = mapM_ (sWriteBS io) chunks+++sClose :: Stream -> IO ()+sClose io+ = withStreamPtr io $ \ ioPtr ->+ svnErr $ _close ioPtr
+ Subversion/String.hsc view
@@ -0,0 +1,65 @@+#include "HsSVN.h"++module Subversion.String+ ( SVN_STRING_T+ , withSvnString+ , withSvnString'+ , peekSvnString+ , peekSvnString'+ )+ where++import Data.ByteString.Base+import qualified Data.ByteString.Char8 as B8+import Foreign.C.Types+import Foreign.Marshal.Alloc+import Foreign.Ptr+import Foreign.Storable+import Subversion.Types++data SVN_STRING_T+++pokeData :: Ptr SVN_STRING_T -> Ptr CChar -> IO ()+pokeData = (#poke svn_string_t, data)++peekData :: Ptr SVN_STRING_T -> IO (Ptr CChar)+peekData = (#peek svn_string_t, data)++pokeLen :: Ptr SVN_STRING_T -> APR_SIZE_T -> IO ()+pokeLen = (#poke svn_string_t, len)++peekLen :: Ptr SVN_STRING_T -> IO APR_SIZE_T+peekLen = (#peek svn_string_t, len)+++withSvnString :: ByteString -> (Ptr SVN_STRING_T -> IO a) -> IO a+withSvnString bs f+ = unsafeUseAsCStringLen bs $ \ (bsBuf, bsLen) ->+ allocaBytes (#size svn_string_t) $ \ obj ->+ do pokeData obj bsBuf+ pokeLen obj (fromIntegral bsLen)+ f obj+++withSvnString' :: Maybe ByteString -> (Ptr SVN_STRING_T -> IO a) -> IO a+withSvnString' Nothing f = f nullPtr+withSvnString' (Just bs) f = withSvnString bs f+++peekSvnString :: Ptr SVN_STRING_T -> IO ByteString+peekSvnString obj+ | obj == nullPtr+ = fail "peekSvnString: got a null pointer"+ | otherwise+ = do buf <- peekData obj+ len <- peekLen obj+ B8.copyCStringLen (buf, fromIntegral len)+++peekSvnString' :: Ptr SVN_STRING_T -> IO (Maybe ByteString)+peekSvnString' obj+ | obj == nullPtr+ = return Nothing+ | otherwise+ = peekSvnString obj >>= return . Just
+ Subversion/Types.hsc view
@@ -0,0 +1,106 @@+{- -*- haskell -*- -}++-- #prune++-- |Some type definitions for Subversion.++#include "HsSVN.h"++module Subversion.Types+ ( RevNum++ , APR_SIZE_T+ , APR_SSIZE_T+ , APR_STATUS_T++ , SVN_BOOLEAN_T+ , SVN_FILESIZE_T+ , SVN_NODE_KIND_T+ , SVN_REVNUM_T+ , SVN_VERSION_T++ , marshalBool+ , unmarshalBool++ , NodeKind(..) -- public+ , unmarshalNodeKind++ , Version(..) -- public+ , peekVersion+ )+ where++import Data.Int+import Data.Word+import Foreign.C.String+import Foreign.Ptr+import Foreign.Storable++-- |@'RevNum'@ represents a revision number.+type RevNum = Int++type APR_SIZE_T = #type apr_size_t+type APR_SSIZE_T = #type apr_ssize_t+type APR_STATUS_T = #type apr_status_t++type SVN_BOOLEAN_T = #type svn_boolean_t+type SVN_FILESIZE_T = #type svn_filesize_t+type SVN_NODE_KIND_T = #type svn_node_kind_t+type SVN_REVNUM_T = #type svn_revnum_t+data SVN_VERSION_T+++marshalBool :: Bool -> SVN_BOOLEAN_T+marshalBool True = (#const TRUE )+marshalBool False = (#const FALSE)++unmarshalBool :: SVN_BOOLEAN_T -> Bool+unmarshalBool (#const TRUE ) = True+unmarshalBool (#const FALSE) = False++-- |@'NodeKind'@ represents a type of node in Subversion filesystem.+data NodeKind+ = NoNode -- ^ The node is absent.+ | FileNode -- ^ The node is a file.+ | DirNode -- ^ The node is a directory.+ deriving (Show, Eq)++unmarshalNodeKind :: SVN_NODE_KIND_T -> NodeKind+unmarshalNodeKind (#const svn_node_none) = NoNode+unmarshalNodeKind (#const svn_node_file) = FileNode+unmarshalNodeKind (#const svn_node_dir ) = DirNode++-- |@'Version'@ is version.+data Version = Version {+ verMajor :: Int -- ^ Major version number.+ , verMinor :: Int -- ^ Minor version number.+ , verPatch :: Int -- ^ Patch number.+ , verTag :: String -- ^ The version tag.+ } deriving (Show, Eq)+++peekVersion :: Ptr SVN_VERSION_T -> IO Version+peekVersion obj+ = do major <- peekVerMajor obj+ minor <- peekVerMinor obj+ patch <- peekVerPatch obj+ tag <- peekVerTag obj >>= peekCString+ return Version {+ verMajor = major+ , verMinor = minor+ , verPatch = patch+ , verTag = tag+ }+++peekVerMajor :: Ptr SVN_VERSION_T -> IO Int+peekVerMajor = (#peek svn_version_t, major)++peekVerMinor :: Ptr SVN_VERSION_T -> IO Int+peekVerMinor = (#peek svn_version_t, minor)++peekVerPatch :: Ptr SVN_VERSION_T -> IO Int+peekVerPatch = (#peek svn_version_t, patch)++peekVerTag :: Ptr SVN_VERSION_T -> IO CString+peekVerTag = (#peek svn_version_t, tag)
+ cbits/HsSVN.c view
@@ -0,0 +1,28 @@+#include "HsSVN.h"+#include <stdlib.h>++/* initialization ************************************************************ */+int HsSVN_initialize() {+ apr_status_t st;++ st = apr_initialize();++ if (st) {+ return -1;+ }++ if (atexit(apr_terminate)) {+ return -1;+ }++ return 0;+}++/* pools ********************************************************************* */+apr_pool_t* HsSVN_svn_pool_create(apr_pool_t* parent) {+ return svn_pool_create(parent);+}++void HsSVN_svn_pool_destroy(apr_pool_t* pool) {+ svn_pool_destroy(pool);+}
+ cbits/HsSVN.h view
@@ -0,0 +1,19 @@+#ifndef HSSVN_H_INCLUDED+#define HSSVN_H_INCLUDED+#include <apr_errno.h>+#include <apr_hash.h>+#include <apr_md5.h>+#include <svn_error.h>+#include <svn_error_codes.h>+#include <svn_fs.h>+#include <svn_pools.h>+#include <svn_repos.h>++/* initialization ************************************************************ */+int HsSVN_initialize();++/* pools ********************************************************************* */+apr_pool_t* HsSVN_svn_pool_create(apr_pool_t* parent);+void HsSVN_svn_pool_destroy(apr_pool_t* pool);++#endif
+ configure view
@@ -0,0 +1,4698 @@+#! /bin/sh+# Guess values for system-dependent variables and create Makefiles.+# Generated by GNU Autoconf 2.60.+#+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,+# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.+# This configure script is free software; the Free Software Foundation+# gives unlimited permission to copy, distribute and modify it.+## --------------------- ##+## M4sh Initialization. ##+## --------------------- ##++# Be Bourne compatible+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+ emulate sh+ NULLCMD=:+ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+ # is contrary to our usage. Disable this feature.+ alias -g '${1+"$@"}'='"$@"'+ setopt NO_GLOB_SUBST+else+ case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac+fi+BIN_SH=xpg4; export BIN_SH # for Tru64+DUALCASE=1; export DUALCASE # for MKS sh+++# PATH needs CR+# Avoid depending upon Character Ranges.+as_cr_letters='abcdefghijklmnopqrstuvwxyz'+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'+as_cr_Letters=$as_cr_letters$as_cr_LETTERS+as_cr_digits='0123456789'+as_cr_alnum=$as_cr_Letters$as_cr_digits++# The user is always right.+if test "${PATH_SEPARATOR+set}" != set; then+ echo "#! /bin/sh" >conf$$.sh+ echo "exit 0" >>conf$$.sh+ chmod +x conf$$.sh+ if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then+ PATH_SEPARATOR=';'+ else+ PATH_SEPARATOR=:+ fi+ rm -f conf$$.sh+fi++# Support unset when possible.+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then+ as_unset=unset+else+ as_unset=false+fi+++# IFS+# We need space, tab and new line, in precisely that order. Quoting is+# there to prevent editors from complaining about space-tab.+# (If _AS_PATH_WALK were called with IFS unset, it would disable word+# splitting by setting IFS to empty value.)+as_nl='+'+IFS=" "" $as_nl"++# Find who we are. Look in the path if we contain no directory separator.+case $0 in+ *[\\/]* ) as_myself=$0 ;;+ *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break+done+IFS=$as_save_IFS++ ;;+esac+# We did not find ourselves, most probably we were run as `sh COMMAND'+# in which case we are not to be found in the path.+if test "x$as_myself" = x; then+ as_myself=$0+fi+if test ! -f "$as_myself"; then+ echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2+ { (exit 1); exit 1; }+fi++# Work around bugs in pre-3.0 UWIN ksh.+for as_var in ENV MAIL MAILPATH+do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+done+PS1='$ '+PS2='> '+PS4='+ '++# NLS nuisances.+for as_var in \+ LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \+ LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \+ LC_TELEPHONE LC_TIME+do+ if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then+ eval $as_var=C; export $as_var+ else+ ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+ fi+done++# Required to use basename.+if expr a : '\(a\)' >/dev/null 2>&1 &&+ test "X`expr 00001 : '.*\(...\)'`" = X001; then+ as_expr=expr+else+ as_expr=false+fi++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then+ as_basename=basename+else+ as_basename=false+fi+++# Name of the executable.+as_me=`$as_basename -- "$0" ||+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \+ X"$0" : 'X\(//\)$' \| \+ X"$0" : 'X\(/\)' \| . 2>/dev/null ||+echo X/"$0" |+ sed '/^.*\/\([^/][^/]*\)\/*$/{+ s//\1/+ q+ }+ /^X\/\(\/\/\)$/{+ s//\1/+ q+ }+ /^X\/\(\/\).*/{+ s//\1/+ q+ }+ s/.*/./; q'`++# CDPATH.+$as_unset CDPATH+++if test "x$CONFIG_SHELL" = x; then+ if (eval ":") 2>/dev/null; then+ as_have_required=yes+else+ as_have_required=no+fi++ if test $as_have_required = yes && (eval ":+(as_func_return () {+ (exit \$1)+}+as_func_success () {+ as_func_return 0+}+as_func_failure () {+ as_func_return 1+}+as_func_ret_success () {+ return 0+}+as_func_ret_failure () {+ return 1+}++exitcode=0+if as_func_success; then+ :+else+ exitcode=1+ echo as_func_success failed.+fi++if as_func_failure; then+ exitcode=1+ echo as_func_failure succeeded.+fi++if as_func_ret_success; then+ :+else+ exitcode=1+ echo as_func_ret_success failed.+fi++if as_func_ret_failure; then+ exitcode=1+ echo as_func_ret_failure succeeded.+fi++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then+ :+else+ exitcode=1+ echo positional parameters were not saved.+fi++test \$exitcode = 0) || { (exit 1); exit 1; }++(+ as_lineno_1=\$LINENO+ as_lineno_2=\$LINENO+ test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&+ test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }+") 2> /dev/null; then+ :+else+ as_candidate_shells=+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in /usr/bin/posix$PATH_SEPARATOR/bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ case $as_dir in+ /*)+ for as_base in sh bash ksh sh5; do+ as_candidate_shells="$as_candidate_shells $as_dir/$as_base"+ done;;+ esac+done+IFS=$as_save_IFS+++ for as_shell in $as_candidate_shells $SHELL; do+ # Try only shells that exist, to save several forks.+ if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&+ { ("$as_shell") 2> /dev/null <<\_ASEOF+# Be Bourne compatible+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+ emulate sh+ NULLCMD=:+ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+ # is contrary to our usage. Disable this feature.+ alias -g '${1+"$@"}'='"$@"'+ setopt NO_GLOB_SUBST+else+ case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac+fi+BIN_SH=xpg4; export BIN_SH # for Tru64+DUALCASE=1; export DUALCASE # for MKS sh++:+_ASEOF+}; then+ CONFIG_SHELL=$as_shell+ as_have_required=yes+ if { "$as_shell" 2> /dev/null <<\_ASEOF+# Be Bourne compatible+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+ emulate sh+ NULLCMD=:+ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+ # is contrary to our usage. Disable this feature.+ alias -g '${1+"$@"}'='"$@"'+ setopt NO_GLOB_SUBST+else+ case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac+fi+BIN_SH=xpg4; export BIN_SH # for Tru64+DUALCASE=1; export DUALCASE # for MKS sh++:+(as_func_return () {+ (exit $1)+}+as_func_success () {+ as_func_return 0+}+as_func_failure () {+ as_func_return 1+}+as_func_ret_success () {+ return 0+}+as_func_ret_failure () {+ return 1+}++exitcode=0+if as_func_success; then+ :+else+ exitcode=1+ echo as_func_success failed.+fi++if as_func_failure; then+ exitcode=1+ echo as_func_failure succeeded.+fi++if as_func_ret_success; then+ :+else+ exitcode=1+ echo as_func_ret_success failed.+fi++if as_func_ret_failure; then+ exitcode=1+ echo as_func_ret_failure succeeded.+fi++if ( set x; as_func_ret_success y && test x = "$1" ); then+ :+else+ exitcode=1+ echo positional parameters were not saved.+fi++test $exitcode = 0) || { (exit 1); exit 1; }++(+ as_lineno_1=$LINENO+ as_lineno_2=$LINENO+ test "x$as_lineno_1" != "x$as_lineno_2" &&+ test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }++_ASEOF+}; then+ break+fi++fi++ done++ if test "x$CONFIG_SHELL" != x; then+ for as_var in BASH_ENV ENV+ do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+ done+ export CONFIG_SHELL+ exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}+fi+++ if test $as_have_required = no; then+ echo This script requires a shell more modern than all the+ echo shells that I found on your system. Please install a+ echo modern shell, or manually run the script under such a+ echo shell if you do have one.+ { (exit 1); exit 1; }+fi+++fi++fi++++(eval "as_func_return () {+ (exit \$1)+}+as_func_success () {+ as_func_return 0+}+as_func_failure () {+ as_func_return 1+}+as_func_ret_success () {+ return 0+}+as_func_ret_failure () {+ return 1+}++exitcode=0+if as_func_success; then+ :+else+ exitcode=1+ echo as_func_success failed.+fi++if as_func_failure; then+ exitcode=1+ echo as_func_failure succeeded.+fi++if as_func_ret_success; then+ :+else+ exitcode=1+ echo as_func_ret_success failed.+fi++if as_func_ret_failure; then+ exitcode=1+ echo as_func_ret_failure succeeded.+fi++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then+ :+else+ exitcode=1+ echo positional parameters were not saved.+fi++test \$exitcode = 0") || {+ echo No shell found that supports shell functions.+ echo Please tell autoconf@gnu.org about your system,+ echo including any error possibly output before this+ echo message+}++++ as_lineno_1=$LINENO+ as_lineno_2=$LINENO+ test "x$as_lineno_1" != "x$as_lineno_2" &&+ test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {++ # Create $as_me.lineno as a copy of $as_myself, but with $LINENO+ # uniformly replaced by the line number. The first 'sed' inserts a+ # line-number line after each line using $LINENO; the second 'sed'+ # does the real work. The second script uses 'N' to pair each+ # line-number line with the line containing $LINENO, and appends+ # trailing '-' during substitution so that $LINENO is not a special+ # case at line end.+ # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the+ # scripts with optimization help from Paolo Bonzini. Blame Lee+ # E. McMahon (1931-1989) for sed's syntax. :-)+ sed -n '+ p+ /[$]LINENO/=+ ' <$as_myself |+ sed '+ s/[$]LINENO.*/&-/+ t lineno+ b+ :lineno+ N+ :loop+ s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/+ t loop+ s/-\n.*//+ ' >$as_me.lineno &&+ chmod +x "$as_me.lineno" ||+ { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2+ { (exit 1); exit 1; }; }++ # Don't try to exec as it changes $[0], causing all sort of problems+ # (the dirname of $[0] is not the place where we might find the+ # original and so on. Autoconf is especially sensitive to this).+ . "./$as_me.lineno"+ # Exit status is that of the last command.+ exit+}+++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then+ as_dirname=dirname+else+ as_dirname=false+fi++ECHO_C= ECHO_N= ECHO_T=+case `echo -n x` in+-n*)+ case `echo 'x\c'` in+ *c*) ECHO_T=' ';; # ECHO_T is single tab character.+ *) ECHO_C='\c';;+ esac;;+*)+ ECHO_N='-n';;+esac++if expr a : '\(a\)' >/dev/null 2>&1 &&+ test "X`expr 00001 : '.*\(...\)'`" = X001; then+ as_expr=expr+else+ as_expr=false+fi++rm -f conf$$ conf$$.exe conf$$.file+if test -d conf$$.dir; then+ rm -f conf$$.dir/conf$$.file+else+ rm -f conf$$.dir+ mkdir conf$$.dir+fi+echo >conf$$.file+if ln -s conf$$.file conf$$ 2>/dev/null; then+ as_ln_s='ln -s'+ # ... but there are two gotchas:+ # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.+ # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.+ # In both cases, we have to default to `cp -p'.+ ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||+ as_ln_s='cp -p'+elif ln conf$$.file conf$$ 2>/dev/null; then+ as_ln_s=ln+else+ as_ln_s='cp -p'+fi+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file+rmdir conf$$.dir 2>/dev/null++if mkdir -p . 2>/dev/null; then+ as_mkdir_p=:+else+ test -d ./-p && rmdir ./-p+ as_mkdir_p=false+fi++# Find out whether ``test -x'' works. Don't use a zero-byte file, as+# systems may use methods other than mode bits to determine executability.+cat >conf$$.file <<_ASEOF+#! /bin/sh+exit 0+_ASEOF+chmod +x conf$$.file+if test -x conf$$.file >/dev/null 2>&1; then+ as_executable_p="test -x"+else+ as_executable_p=:+fi+rm -f conf$$.file++# Sed expression to map a string onto a valid CPP name.+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"++# Sed expression to map a string onto a valid variable name.+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"++++exec 7<&0 </dev/null 6>&1++# Name of the host.+# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,+# so uname gets run too.+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`++#+# Initializations.+#+ac_default_prefix=/usr/local+ac_clean_files=+ac_config_libobj_dir=.+LIBOBJS=+cross_compiling=no+subdirs=+MFLAGS=+MAKEFLAGS=+SHELL=${CONFIG_SHELL-/bin/sh}++# Identity of this package.+PACKAGE_NAME=+PACKAGE_TARNAME=+PACKAGE_VERSION=+PACKAGE_STRING=+PACKAGE_BUGREPORT=++ac_unique_file="HsSVN"+ac_unique_file="HsSVN.cabal"+# Factoring default headers for most tests.+ac_includes_default="\+#include <stdio.h>+#if HAVE_SYS_TYPES_H+# include <sys/types.h>+#endif+#if HAVE_SYS_STAT_H+# include <sys/stat.h>+#endif+#if STDC_HEADERS+# include <stdlib.h>+# include <stddef.h>+#else+# if HAVE_STDLIB_H+# include <stdlib.h>+# endif+#endif+#if HAVE_STRING_H+# if !STDC_HEADERS && HAVE_MEMORY_H+# include <memory.h>+# endif+# include <string.h>+#endif+#if HAVE_STRINGS_H+# include <strings.h>+#endif+#if HAVE_INTTYPES_H+# include <inttypes.h>+#endif+#if HAVE_STDINT_H+# include <stdint.h>+#endif+#if HAVE_UNISTD_H+# include <unistd.h>+#endif"++ac_subst_vars='SHELL+PATH_SEPARATOR+PACKAGE_NAME+PACKAGE_TARNAME+PACKAGE_VERSION+PACKAGE_STRING+PACKAGE_BUGREPORT+exec_prefix+prefix+program_transform_name+bindir+sbindir+libexecdir+datarootdir+datadir+sysconfdir+sharedstatedir+localstatedir+includedir+oldincludedir+docdir+infodir+htmldir+dvidir+pdfdir+psdir+libdir+localedir+mandir+DEFS+ECHO_C+ECHO_N+ECHO_T+LIBS+build_alias+host_alias+target_alias+EXTRA_CPPFLAGS+EXTRA_LDFLAGS+SVN_CFLAGS+SVN_LIBS+CC+CFLAGS+LDFLAGS+CPPFLAGS+ac_ct_CC+EXEEXT+OBJEXT+CPP+GREP+EGREP+APR_CONFIG+LIBOBJS+LTLIBOBJS'+ac_subst_files=''+ ac_precious_vars='build_alias+host_alias+target_alias+EXTRA_CPPFLAGS+EXTRA_LDFLAGS+CC+CFLAGS+LDFLAGS+CPPFLAGS+CPP+APR_CONFIG'+++# Initialize some variables set by options.+ac_init_help=+ac_init_version=false+# The variables have the same names as the options, with+# dashes changed to underlines.+cache_file=/dev/null+exec_prefix=NONE+no_create=+no_recursion=+prefix=NONE+program_prefix=NONE+program_suffix=NONE+program_transform_name=s,x,x,+silent=+site=+srcdir=+verbose=+x_includes=NONE+x_libraries=NONE++# Installation directory options.+# These are left unexpanded so users can "make install exec_prefix=/foo"+# and all the variables that are supposed to be based on exec_prefix+# by default will actually change.+# Use braces instead of parens because sh, perl, etc. also accept them.+# (The list follows the same order as the GNU Coding Standards.)+bindir='${exec_prefix}/bin'+sbindir='${exec_prefix}/sbin'+libexecdir='${exec_prefix}/libexec'+datarootdir='${prefix}/share'+datadir='${datarootdir}'+sysconfdir='${prefix}/etc'+sharedstatedir='${prefix}/com'+localstatedir='${prefix}/var'+includedir='${prefix}/include'+oldincludedir='/usr/include'+docdir='${datarootdir}/doc/${PACKAGE}'+infodir='${datarootdir}/info'+htmldir='${docdir}'+dvidir='${docdir}'+pdfdir='${docdir}'+psdir='${docdir}'+libdir='${exec_prefix}/lib'+localedir='${datarootdir}/locale'+mandir='${datarootdir}/man'++ac_prev=+ac_dashdash=+for ac_option+do+ # If the previous option needs an argument, assign it.+ if test -n "$ac_prev"; then+ eval $ac_prev=\$ac_option+ ac_prev=+ continue+ fi++ case $ac_option in+ *=*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;+ *) ac_optarg=yes ;;+ esac++ # Accept the important Cygnus configure options, so we can diagnose typos.++ case $ac_dashdash$ac_option in+ --)+ ac_dashdash=yes ;;++ -bindir | --bindir | --bindi | --bind | --bin | --bi)+ ac_prev=bindir ;;+ -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)+ bindir=$ac_optarg ;;++ -build | --build | --buil | --bui | --bu)+ ac_prev=build_alias ;;+ -build=* | --build=* | --buil=* | --bui=* | --bu=*)+ build_alias=$ac_optarg ;;++ -cache-file | --cache-file | --cache-fil | --cache-fi \+ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)+ ac_prev=cache_file ;;+ -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \+ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)+ cache_file=$ac_optarg ;;++ --config-cache | -C)+ cache_file=config.cache ;;++ -datadir | --datadir | --datadi | --datad)+ ac_prev=datadir ;;+ -datadir=* | --datadir=* | --datadi=* | --datad=*)+ datadir=$ac_optarg ;;++ -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \+ | --dataroo | --dataro | --datar)+ ac_prev=datarootdir ;;+ -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \+ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)+ datarootdir=$ac_optarg ;;++ -disable-* | --disable-*)+ ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`+ # Reject names that are not valid shell variable names.+ expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&+ { echo "$as_me: error: invalid feature name: $ac_feature" >&2+ { (exit 1); exit 1; }; }+ ac_feature=`echo $ac_feature | sed 's/-/_/g'`+ eval enable_$ac_feature=no ;;++ -docdir | --docdir | --docdi | --doc | --do)+ ac_prev=docdir ;;+ -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)+ docdir=$ac_optarg ;;++ -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)+ ac_prev=dvidir ;;+ -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)+ dvidir=$ac_optarg ;;++ -enable-* | --enable-*)+ ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`+ # Reject names that are not valid shell variable names.+ expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&+ { echo "$as_me: error: invalid feature name: $ac_feature" >&2+ { (exit 1); exit 1; }; }+ ac_feature=`echo $ac_feature | sed 's/-/_/g'`+ eval enable_$ac_feature=\$ac_optarg ;;++ -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \+ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \+ | --exec | --exe | --ex)+ ac_prev=exec_prefix ;;+ -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \+ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \+ | --exec=* | --exe=* | --ex=*)+ exec_prefix=$ac_optarg ;;++ -gas | --gas | --ga | --g)+ # Obsolete; use --with-gas.+ with_gas=yes ;;++ -help | --help | --hel | --he | -h)+ ac_init_help=long ;;+ -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)+ ac_init_help=recursive ;;+ -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)+ ac_init_help=short ;;++ -host | --host | --hos | --ho)+ ac_prev=host_alias ;;+ -host=* | --host=* | --hos=* | --ho=*)+ host_alias=$ac_optarg ;;++ -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)+ ac_prev=htmldir ;;+ -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \+ | --ht=*)+ htmldir=$ac_optarg ;;++ -includedir | --includedir | --includedi | --included | --include \+ | --includ | --inclu | --incl | --inc)+ ac_prev=includedir ;;+ -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \+ | --includ=* | --inclu=* | --incl=* | --inc=*)+ includedir=$ac_optarg ;;++ -infodir | --infodir | --infodi | --infod | --info | --inf)+ ac_prev=infodir ;;+ -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)+ infodir=$ac_optarg ;;++ -libdir | --libdir | --libdi | --libd)+ ac_prev=libdir ;;+ -libdir=* | --libdir=* | --libdi=* | --libd=*)+ libdir=$ac_optarg ;;++ -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \+ | --libexe | --libex | --libe)+ ac_prev=libexecdir ;;+ -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \+ | --libexe=* | --libex=* | --libe=*)+ libexecdir=$ac_optarg ;;++ -localedir | --localedir | --localedi | --localed | --locale)+ ac_prev=localedir ;;+ -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)+ localedir=$ac_optarg ;;++ -localstatedir | --localstatedir | --localstatedi | --localstated \+ | --localstate | --localstat | --localsta | --localst | --locals)+ ac_prev=localstatedir ;;+ -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \+ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)+ localstatedir=$ac_optarg ;;++ -mandir | --mandir | --mandi | --mand | --man | --ma | --m)+ ac_prev=mandir ;;+ -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)+ mandir=$ac_optarg ;;++ -nfp | --nfp | --nf)+ # Obsolete; use --without-fp.+ with_fp=no ;;++ -no-create | --no-create | --no-creat | --no-crea | --no-cre \+ | --no-cr | --no-c | -n)+ no_create=yes ;;++ -no-recursion | --no-recursion | --no-recursio | --no-recursi \+ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)+ no_recursion=yes ;;++ -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \+ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \+ | --oldin | --oldi | --old | --ol | --o)+ ac_prev=oldincludedir ;;+ -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \+ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \+ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)+ oldincludedir=$ac_optarg ;;++ -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)+ ac_prev=prefix ;;+ -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)+ prefix=$ac_optarg ;;++ -program-prefix | --program-prefix | --program-prefi | --program-pref \+ | --program-pre | --program-pr | --program-p)+ ac_prev=program_prefix ;;+ -program-prefix=* | --program-prefix=* | --program-prefi=* \+ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)+ program_prefix=$ac_optarg ;;++ -program-suffix | --program-suffix | --program-suffi | --program-suff \+ | --program-suf | --program-su | --program-s)+ ac_prev=program_suffix ;;+ -program-suffix=* | --program-suffix=* | --program-suffi=* \+ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)+ program_suffix=$ac_optarg ;;++ -program-transform-name | --program-transform-name \+ | --program-transform-nam | --program-transform-na \+ | --program-transform-n | --program-transform- \+ | --program-transform | --program-transfor \+ | --program-transfo | --program-transf \+ | --program-trans | --program-tran \+ | --progr-tra | --program-tr | --program-t)+ ac_prev=program_transform_name ;;+ -program-transform-name=* | --program-transform-name=* \+ | --program-transform-nam=* | --program-transform-na=* \+ | --program-transform-n=* | --program-transform-=* \+ | --program-transform=* | --program-transfor=* \+ | --program-transfo=* | --program-transf=* \+ | --program-trans=* | --program-tran=* \+ | --progr-tra=* | --program-tr=* | --program-t=*)+ program_transform_name=$ac_optarg ;;++ -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)+ ac_prev=pdfdir ;;+ -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)+ pdfdir=$ac_optarg ;;++ -psdir | --psdir | --psdi | --psd | --ps)+ ac_prev=psdir ;;+ -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)+ psdir=$ac_optarg ;;++ -q | -quiet | --quiet | --quie | --qui | --qu | --q \+ | -silent | --silent | --silen | --sile | --sil)+ silent=yes ;;++ -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)+ ac_prev=sbindir ;;+ -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \+ | --sbi=* | --sb=*)+ sbindir=$ac_optarg ;;++ -sharedstatedir | --sharedstatedir | --sharedstatedi \+ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \+ | --sharedst | --shareds | --shared | --share | --shar \+ | --sha | --sh)+ ac_prev=sharedstatedir ;;+ -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \+ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \+ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \+ | --sha=* | --sh=*)+ sharedstatedir=$ac_optarg ;;++ -site | --site | --sit)+ ac_prev=site ;;+ -site=* | --site=* | --sit=*)+ site=$ac_optarg ;;++ -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)+ ac_prev=srcdir ;;+ -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)+ srcdir=$ac_optarg ;;++ -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \+ | --syscon | --sysco | --sysc | --sys | --sy)+ ac_prev=sysconfdir ;;+ -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \+ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)+ sysconfdir=$ac_optarg ;;++ -target | --target | --targe | --targ | --tar | --ta | --t)+ ac_prev=target_alias ;;+ -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)+ target_alias=$ac_optarg ;;++ -v | -verbose | --verbose | --verbos | --verbo | --verb)+ verbose=yes ;;++ -version | --version | --versio | --versi | --vers | -V)+ ac_init_version=: ;;++ -with-* | --with-*)+ ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`+ # Reject names that are not valid shell variable names.+ expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&+ { echo "$as_me: error: invalid package name: $ac_package" >&2+ { (exit 1); exit 1; }; }+ ac_package=`echo $ac_package| sed 's/-/_/g'`+ eval with_$ac_package=\$ac_optarg ;;++ -without-* | --without-*)+ ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`+ # Reject names that are not valid shell variable names.+ expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&+ { echo "$as_me: error: invalid package name: $ac_package" >&2+ { (exit 1); exit 1; }; }+ ac_package=`echo $ac_package | sed 's/-/_/g'`+ eval with_$ac_package=no ;;++ --x)+ # Obsolete; use --with-x.+ with_x=yes ;;++ -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \+ | --x-incl | --x-inc | --x-in | --x-i)+ ac_prev=x_includes ;;+ -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \+ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)+ x_includes=$ac_optarg ;;++ -x-libraries | --x-libraries | --x-librarie | --x-librari \+ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)+ ac_prev=x_libraries ;;+ -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \+ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)+ x_libraries=$ac_optarg ;;++ -*) { echo "$as_me: error: unrecognized option: $ac_option+Try \`$0 --help' for more information." >&2+ { (exit 1); exit 1; }; }+ ;;++ *=*)+ ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`+ # Reject names that are not valid shell variable names.+ expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&+ { echo "$as_me: error: invalid variable name: $ac_envvar" >&2+ { (exit 1); exit 1; }; }+ eval $ac_envvar=\$ac_optarg+ export $ac_envvar ;;++ *)+ # FIXME: should be removed in autoconf 3.0.+ echo "$as_me: WARNING: you should use --build, --host, --target" >&2+ expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&+ echo "$as_me: WARNING: invalid host type: $ac_option" >&2+ : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}+ ;;++ esac+done++if test -n "$ac_prev"; then+ ac_option=--`echo $ac_prev | sed 's/_/-/g'`+ { echo "$as_me: error: missing argument to $ac_option" >&2+ { (exit 1); exit 1; }; }+fi++# Be sure to have absolute directory names.+for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \+ datadir sysconfdir sharedstatedir localstatedir includedir \+ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \+ libdir localedir mandir+do+ eval ac_val=\$$ac_var+ case $ac_val in+ [\\/$]* | ?:[\\/]* ) continue;;+ NONE | '' ) case $ac_var in *prefix ) continue;; esac;;+ esac+ { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2+ { (exit 1); exit 1; }; }+done++# There might be people who depend on the old broken behavior: `$host'+# used to hold the argument of --host etc.+# FIXME: To remove some day.+build=$build_alias+host=$host_alias+target=$target_alias++# FIXME: To remove some day.+if test "x$host_alias" != x; then+ if test "x$build_alias" = x; then+ cross_compiling=maybe+ echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.+ If a cross compiler is detected then cross compile mode will be used." >&2+ elif test "x$build_alias" != "x$host_alias"; then+ cross_compiling=yes+ fi+fi++ac_tool_prefix=+test -n "$host_alias" && ac_tool_prefix=$host_alias-++test "$silent" = yes && exec 6>/dev/null+++ac_pwd=`pwd` && test -n "$ac_pwd" &&+ac_ls_di=`ls -di .` &&+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||+ { echo "$as_me: error: Working directory cannot be determined" >&2+ { (exit 1); exit 1; }; }+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||+ { echo "$as_me: error: pwd does not report name of working directory" >&2+ { (exit 1); exit 1; }; }+++# Find the source files, if location was not specified.+if test -z "$srcdir"; then+ ac_srcdir_defaulted=yes+ # Try the directory containing this script, then the parent directory.+ ac_confdir=`$as_dirname -- "$0" ||+$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+ X"$0" : 'X\(//\)[^/]' \| \+ X"$0" : 'X\(//\)$' \| \+ X"$0" : 'X\(/\)' \| . 2>/dev/null ||+echo X"$0" |+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{+ s//\1/+ q+ }+ /^X\(\/\/\)[^/].*/{+ s//\1/+ q+ }+ /^X\(\/\/\)$/{+ s//\1/+ q+ }+ /^X\(\/\).*/{+ s//\1/+ q+ }+ s/.*/./; q'`+ srcdir=$ac_confdir+ if test ! -r "$srcdir/$ac_unique_file"; then+ srcdir=..+ fi+else+ ac_srcdir_defaulted=no+fi+if test ! -r "$srcdir/$ac_unique_file"; then+ test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."+ { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2+ { (exit 1); exit 1; }; }+fi+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"+ac_abs_confdir=`(+ cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2+ { (exit 1); exit 1; }; }+ pwd)`+# When building in place, set srcdir=.+if test "$ac_abs_confdir" = "$ac_pwd"; then+ srcdir=.+fi+# Remove unnecessary trailing slashes from srcdir.+# Double slashes in file names in object file debugging info+# mess up M-x gdb in Emacs.+case $srcdir in+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;+esac+for ac_var in $ac_precious_vars; do+ eval ac_env_${ac_var}_set=\${${ac_var}+set}+ eval ac_env_${ac_var}_value=\$${ac_var}+ eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}+ eval ac_cv_env_${ac_var}_value=\$${ac_var}+done++#+# Report the --help message.+#+if test "$ac_init_help" = "long"; then+ # Omit some internal or obsolete options to make the list less imposing.+ # This message is too long to be a string in the A/UX 3.1 sh.+ cat <<_ACEOF+\`configure' configures this package to adapt to many kinds of systems.++Usage: $0 [OPTION]... [VAR=VALUE]...++To assign environment variables (e.g., CC, CFLAGS...), specify them as+VAR=VALUE. See below for descriptions of some of the useful variables.++Defaults for the options are specified in brackets.++Configuration:+ -h, --help display this help and exit+ --help=short display options specific to this package+ --help=recursive display the short help of all the included packages+ -V, --version display version information and exit+ -q, --quiet, --silent do not print \`checking...' messages+ --cache-file=FILE cache test results in FILE [disabled]+ -C, --config-cache alias for \`--cache-file=config.cache'+ -n, --no-create do not create output files+ --srcdir=DIR find the sources in DIR [configure dir or \`..']++Installation directories:+ --prefix=PREFIX install architecture-independent files in PREFIX+ [$ac_default_prefix]+ --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX+ [PREFIX]++By default, \`make install' will install all the files in+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify+an installation prefix other than \`$ac_default_prefix' using \`--prefix',+for instance \`--prefix=\$HOME'.++For better control, use the options below.++Fine tuning of the installation directories:+ --bindir=DIR user executables [EPREFIX/bin]+ --sbindir=DIR system admin executables [EPREFIX/sbin]+ --libexecdir=DIR program executables [EPREFIX/libexec]+ --sysconfdir=DIR read-only single-machine data [PREFIX/etc]+ --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]+ --localstatedir=DIR modifiable single-machine data [PREFIX/var]+ --libdir=DIR object code libraries [EPREFIX/lib]+ --includedir=DIR C header files [PREFIX/include]+ --oldincludedir=DIR C header files for non-gcc [/usr/include]+ --datarootdir=DIR read-only arch.-independent data root [PREFIX/share]+ --datadir=DIR read-only architecture-independent data [DATAROOTDIR]+ --infodir=DIR info documentation [DATAROOTDIR/info]+ --localedir=DIR locale-dependent data [DATAROOTDIR/locale]+ --mandir=DIR man documentation [DATAROOTDIR/man]+ --docdir=DIR documentation root [DATAROOTDIR/doc/PACKAGE]+ --htmldir=DIR html documentation [DOCDIR]+ --dvidir=DIR dvi documentation [DOCDIR]+ --pdfdir=DIR pdf documentation [DOCDIR]+ --psdir=DIR ps documentation [DOCDIR]+_ACEOF++ cat <<\_ACEOF+_ACEOF+fi++if test -n "$ac_init_help"; then++ cat <<\_ACEOF++Some influential environment variables:+ EXTRA_CPPFLAGS+ extra CPPFLAGS to find subversion+ EXTRA_LDFLAGS+ extra LDFLAGS to find subversion+ CC C compiler command+ CFLAGS C compiler flags+ LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a+ nonstandard directory <lib dir>+ CPPFLAGS C/C++/Objective C preprocessor flags, e.g. -I<include dir> if+ you have headers in a nonstandard directory <include dir>+ CPP C preprocessor+ APR_CONFIG apr-config to use++Use these variables to override the choices made by `configure' or to help+it to find libraries and programs with nonstandard names/locations.++_ACEOF+ac_status=$?+fi++if test "$ac_init_help" = "recursive"; then+ # If there are subdirs, report their specific --help.+ for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue+ test -d "$ac_dir" || continue+ ac_builddir=.++case "$ac_dir" in+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;+*)+ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`+ # A ".." for each directory in $ac_dir_suffix.+ ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`+ case $ac_top_builddir_sub in+ "") ac_top_builddir_sub=. ac_top_build_prefix= ;;+ *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;+ esac ;;+esac+ac_abs_top_builddir=$ac_pwd+ac_abs_builddir=$ac_pwd$ac_dir_suffix+# for backward compatibility:+ac_top_builddir=$ac_top_build_prefix++case $srcdir in+ .) # We are building in place.+ ac_srcdir=.+ ac_top_srcdir=$ac_top_builddir_sub+ ac_abs_top_srcdir=$ac_pwd ;;+ [\\/]* | ?:[\\/]* ) # Absolute name.+ ac_srcdir=$srcdir$ac_dir_suffix;+ ac_top_srcdir=$srcdir+ ac_abs_top_srcdir=$srcdir ;;+ *) # Relative name.+ ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix+ ac_top_srcdir=$ac_top_build_prefix$srcdir+ ac_abs_top_srcdir=$ac_pwd/$srcdir ;;+esac+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix++ cd "$ac_dir" || { ac_status=$?; continue; }+ # Check for guested configure.+ if test -f "$ac_srcdir/configure.gnu"; then+ echo &&+ $SHELL "$ac_srcdir/configure.gnu" --help=recursive+ elif test -f "$ac_srcdir/configure"; then+ echo &&+ $SHELL "$ac_srcdir/configure" --help=recursive+ else+ echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2+ fi || ac_status=$?+ cd "$ac_pwd" || { ac_status=$?; break; }+ done+fi++test -n "$ac_init_help" && exit $ac_status+if $ac_init_version; then+ cat <<\_ACEOF+configure+generated by GNU Autoconf 2.60++Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,+2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.+This configure script is free software; the Free Software Foundation+gives unlimited permission to copy, distribute and modify it.+_ACEOF+ exit+fi+cat >config.log <<_ACEOF+This file contains any messages produced by compilers while+running configure, to aid debugging if configure makes a mistake.++It was created by $as_me, which was+generated by GNU Autoconf 2.60. Invocation command line was++ $ $0 $@++_ACEOF+exec 5>>config.log+{+cat <<_ASUNAME+## --------- ##+## Platform. ##+## --------- ##++hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`+uname -m = `(uname -m) 2>/dev/null || echo unknown`+uname -r = `(uname -r) 2>/dev/null || echo unknown`+uname -s = `(uname -s) 2>/dev/null || echo unknown`+uname -v = `(uname -v) 2>/dev/null || echo unknown`++/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`+/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`++/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`+/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`+/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`+/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`+/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`+/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`++_ASUNAME++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ echo "PATH: $as_dir"+done+IFS=$as_save_IFS++} >&5++cat >&5 <<_ACEOF+++## ----------- ##+## Core tests. ##+## ----------- ##++_ACEOF+++# Keep a trace of the command line.+# Strip out --no-create and --no-recursion so they do not pile up.+# Strip out --silent because we don't want to record it for future runs.+# Also quote any args containing shell meta-characters.+# Make two passes to allow for proper duplicate-argument suppression.+ac_configure_args=+ac_configure_args0=+ac_configure_args1=+ac_must_keep_next=false+for ac_pass in 1 2+do+ for ac_arg+ do+ case $ac_arg in+ -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;+ -q | -quiet | --quiet | --quie | --qui | --qu | --q \+ | -silent | --silent | --silen | --sile | --sil)+ continue ;;+ *\'*)+ ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;+ esac+ case $ac_pass in+ 1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;+ 2)+ ac_configure_args1="$ac_configure_args1 '$ac_arg'"+ if test $ac_must_keep_next = true; then+ ac_must_keep_next=false # Got value, back to normal.+ else+ case $ac_arg in+ *=* | --config-cache | -C | -disable-* | --disable-* \+ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \+ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \+ | -with-* | --with-* | -without-* | --without-* | --x)+ case "$ac_configure_args0 " in+ "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;+ esac+ ;;+ -* ) ac_must_keep_next=true ;;+ esac+ fi+ ac_configure_args="$ac_configure_args '$ac_arg'"+ ;;+ esac+ done+done+$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }+$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }++# When interrupted or exit'd, cleanup temporary files, and complete+# config.log. We remove comments because anyway the quotes in there+# would cause problems or look ugly.+# WARNING: Use '\'' to represent an apostrophe within the trap.+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.+trap 'exit_status=$?+ # Save into config.log some information that might help in debugging.+ {+ echo++ cat <<\_ASBOX+## ---------------- ##+## Cache variables. ##+## ---------------- ##+_ASBOX+ echo+ # The following way of writing the cache mishandles newlines in values,+(+ for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do+ eval ac_val=\$$ac_var+ case $ac_val in #(+ *${as_nl}*)+ case $ac_var in #(+ *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5+echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;+ esac+ case $ac_var in #(+ _ | IFS | as_nl) ;; #(+ *) $as_unset $ac_var ;;+ esac ;;+ esac+ done+ (set) 2>&1 |+ case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(+ *${as_nl}ac_space=\ *)+ sed -n \+ "s/'\''/'\''\\\\'\'''\''/g;+ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"+ ;; #(+ *)+ sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"+ ;;+ esac |+ sort+)+ echo++ cat <<\_ASBOX+## ----------------- ##+## Output variables. ##+## ----------------- ##+_ASBOX+ echo+ for ac_var in $ac_subst_vars+ do+ eval ac_val=\$$ac_var+ case $ac_val in+ *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;+ esac+ echo "$ac_var='\''$ac_val'\''"+ done | sort+ echo++ if test -n "$ac_subst_files"; then+ cat <<\_ASBOX+## ------------------- ##+## File substitutions. ##+## ------------------- ##+_ASBOX+ echo+ for ac_var in $ac_subst_files+ do+ eval ac_val=\$$ac_var+ case $ac_val in+ *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;+ esac+ echo "$ac_var='\''$ac_val'\''"+ done | sort+ echo+ fi++ if test -s confdefs.h; then+ cat <<\_ASBOX+## ----------- ##+## confdefs.h. ##+## ----------- ##+_ASBOX+ echo+ cat confdefs.h+ echo+ fi+ test "$ac_signal" != 0 &&+ echo "$as_me: caught signal $ac_signal"+ echo "$as_me: exit $exit_status"+ } >&5+ rm -f core *.core core.conftest.* &&+ rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&+ exit $exit_status+' 0+for ac_signal in 1 2 13 15; do+ trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal+done+ac_signal=0++# confdefs.h avoids OS command line length limits that DEFS can exceed.+rm -f -r conftest* confdefs.h++# Predefined preprocessor variables.++cat >>confdefs.h <<_ACEOF+#define PACKAGE_NAME "$PACKAGE_NAME"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_VERSION "$PACKAGE_VERSION"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_STRING "$PACKAGE_STRING"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"+_ACEOF+++# Let the site file select an alternate cache file if it wants to.+# Prefer explicitly selected file to automatically selected ones.+if test -n "$CONFIG_SITE"; then+ set x "$CONFIG_SITE"+elif test "x$prefix" != xNONE; then+ set x "$prefix/share/config.site" "$prefix/etc/config.site"+else+ set x "$ac_default_prefix/share/config.site" \+ "$ac_default_prefix/etc/config.site"+fi+shift+for ac_site_file+do+ if test -r "$ac_site_file"; then+ { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5+echo "$as_me: loading site script $ac_site_file" >&6;}+ sed 's/^/| /' "$ac_site_file" >&5+ . "$ac_site_file"+ fi+done++if test -r "$cache_file"; then+ # Some versions of bash will fail to source /dev/null (special+ # files actually), so we avoid doing that.+ if test -f "$cache_file"; then+ { echo "$as_me:$LINENO: loading cache $cache_file" >&5+echo "$as_me: loading cache $cache_file" >&6;}+ case $cache_file in+ [\\/]* | ?:[\\/]* ) . "$cache_file";;+ *) . "./$cache_file";;+ esac+ fi+else+ { echo "$as_me:$LINENO: creating cache $cache_file" >&5+echo "$as_me: creating cache $cache_file" >&6;}+ >$cache_file+fi++# Check that the precious variables saved in the cache have kept the same+# value.+ac_cache_corrupted=false+for ac_var in $ac_precious_vars; do+ eval ac_old_set=\$ac_cv_env_${ac_var}_set+ eval ac_new_set=\$ac_env_${ac_var}_set+ eval ac_old_val=\$ac_cv_env_${ac_var}_value+ eval ac_new_val=\$ac_env_${ac_var}_value+ case $ac_old_set,$ac_new_set in+ set,)+ { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5+echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}+ ac_cache_corrupted=: ;;+ ,set)+ { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5+echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}+ ac_cache_corrupted=: ;;+ ,);;+ *)+ if test "x$ac_old_val" != "x$ac_new_val"; then+ { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5+echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}+ { echo "$as_me:$LINENO: former value: $ac_old_val" >&5+echo "$as_me: former value: $ac_old_val" >&2;}+ { echo "$as_me:$LINENO: current value: $ac_new_val" >&5+echo "$as_me: current value: $ac_new_val" >&2;}+ ac_cache_corrupted=:+ fi;;+ esac+ # Pass precious variables to config.status.+ if test "$ac_new_set" = set; then+ case $ac_new_val in+ *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;+ *) ac_arg=$ac_var=$ac_new_val ;;+ esac+ case " $ac_configure_args " in+ *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.+ *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;+ esac+ fi+done+if $ac_cache_corrupted; then+ { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5+echo "$as_me: error: changes in the environment can compromise the build" >&2;}+ { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5+echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}+ { (exit 1); exit 1; }; }+fi++++++++++++++++++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu++++++#+# Checks for Subversion...+#+# FIXME: we can get rid of these ugly checks when we got svn-config or+# something alike.+#+++CPPFLAGS="$EXTRA_CPPFLAGS $CPPFLAGS"+LDFLAGS="$EXTRA_LDFLAGS $LDFLAGS"++SVN_CFLAGS="$EXTRA_CPPFLAGS"+SVN_LIBS="$EXTRA_LIBS -lsvn_subr-1 -lsvn_repos-1 -lsvn_fs-1"++++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+if test -n "$ac_tool_prefix"; then+ # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.+set dummy ${ac_tool_prefix}gcc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$CC"; then+ ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then+ ac_cv_prog_CC="${ac_tool_prefix}gcc"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+ { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++fi+if test -z "$ac_cv_prog_CC"; then+ ac_ct_CC=$CC+ # Extract the first word of "gcc", so it can be a program name with args.+set dummy gcc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$ac_ct_CC"; then+ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then+ ac_cv_prog_ac_ct_CC="gcc"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++fi+fi+ac_ct_CC=$ac_cv_prog_ac_ct_CC+if test -n "$ac_ct_CC"; then+ { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5+echo "${ECHO_T}$ac_ct_CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi++ if test "x$ac_ct_CC" = x; then+ CC=""+ else+ case $cross_compiling:$ac_tool_warned in+yes:)+{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet. If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&5+echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet. If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&2;}+ac_tool_warned=yes ;;+esac+ CC=$ac_ct_CC+ fi+else+ CC="$ac_cv_prog_CC"+fi++if test -z "$CC"; then+ if test -n "$ac_tool_prefix"; then+ # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.+set dummy ${ac_tool_prefix}cc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$CC"; then+ ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then+ ac_cv_prog_CC="${ac_tool_prefix}cc"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+ { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++ fi+fi+if test -z "$CC"; then+ # Extract the first word of "cc", so it can be a program name with args.+set dummy cc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$CC"; then+ ac_cv_prog_CC="$CC" # Let the user override the test.+else+ ac_prog_rejected=no+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then+ if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then+ ac_prog_rejected=yes+ continue+ fi+ ac_cv_prog_CC="cc"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++if test $ac_prog_rejected = yes; then+ # We found a bogon in the path, so make sure we never use it.+ set dummy $ac_cv_prog_CC+ shift+ if test $# != 0; then+ # We chose a different compiler from the bogus one.+ # However, it has the same basename, so the bogon will be chosen+ # first if we set CC to just the basename; use the full file name.+ shift+ ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"+ fi+fi+fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+ { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++fi+if test -z "$CC"; then+ if test -n "$ac_tool_prefix"; then+ for ac_prog in cl.exe+ do+ # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.+set dummy $ac_tool_prefix$ac_prog; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$CC"; then+ ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then+ ac_cv_prog_CC="$ac_tool_prefix$ac_prog"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+ { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++ test -n "$CC" && break+ done+fi+if test -z "$CC"; then+ ac_ct_CC=$CC+ for ac_prog in cl.exe+do+ # Extract the first word of "$ac_prog", so it can be a program name with args.+set dummy $ac_prog; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$ac_ct_CC"; then+ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then+ ac_cv_prog_ac_ct_CC="$ac_prog"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++fi+fi+ac_ct_CC=$ac_cv_prog_ac_ct_CC+if test -n "$ac_ct_CC"; then+ { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5+echo "${ECHO_T}$ac_ct_CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++ test -n "$ac_ct_CC" && break+done++ if test "x$ac_ct_CC" = x; then+ CC=""+ else+ case $cross_compiling:$ac_tool_warned in+yes:)+{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet. If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&5+echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet. If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&2;}+ac_tool_warned=yes ;;+esac+ CC=$ac_ct_CC+ fi+fi++fi+++test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH+See \`config.log' for more details." >&5+echo "$as_me: error: no acceptable C compiler found in \$PATH+See \`config.log' for more details." >&2;}+ { (exit 1); exit 1; }; }++# Provide some information about the compiler.+echo "$as_me:$LINENO: checking for C compiler version" >&5+ac_compiler=`set X $ac_compile; echo $2`+{ (ac_try="$ac_compiler --version >&5"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compiler --version >&5") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }+{ (ac_try="$ac_compiler -v >&5"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compiler -v >&5") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }+{ (ac_try="$ac_compiler -V >&5"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compiler -V >&5") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }++cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{++ ;+ return 0;+}+_ACEOF+ac_clean_files_save=$ac_clean_files+ac_clean_files="$ac_clean_files a.out a.exe b.out"+# Try to create an executable without -o first, disregard a.out.+# It will help us diagnose broken compilers, and finding out an intuition+# of exeext.+{ echo "$as_me:$LINENO: checking for C compiler default output file name" >&5+echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6; }+ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`+#+# List of possible output files, starting from the most likely.+# The algorithm is not robust to junk in `.', hence go to wildcards (a.*)+# only as a last resort. b.out is created by i960 compilers.+ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out'+#+# The IRIX 6 linker writes into existing files which may not be+# executable, retaining their permissions. Remove them first so a+# subsequent execution test works.+ac_rmfiles=+for ac_file in $ac_files+do+ case $ac_file in+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;+ * ) ac_rmfiles="$ac_rmfiles $ac_file";;+ esac+done+rm -f $ac_rmfiles++if { (ac_try="$ac_link_default"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_link_default") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; then+ # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'+# in a Makefile. We should not override ac_cv_exeext if it was cached,+# so that the user can short-circuit this test for compilers unknown to+# Autoconf.+for ac_file in $ac_files+do+ test -f "$ac_file" || continue+ case $ac_file in+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj )+ ;;+ [ab].out )+ # We found the default executable, but exeext='' is most+ # certainly right.+ break;;+ *.* )+ if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;+ then :; else+ ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`+ fi+ # We set ac_cv_exeext here because the later test for it is not+ # safe: cross compilers may not add the suffix if given an `-o'+ # argument, so we may need to know it at that point already.+ # Even if this section looks crufty: it has the advantage of+ # actually working.+ break;;+ * )+ break;;+ esac+done+test "$ac_cv_exeext" = no && ac_cv_exeext=++else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++{ { echo "$as_me:$LINENO: error: C compiler cannot create executables+See \`config.log' for more details." >&5+echo "$as_me: error: C compiler cannot create executables+See \`config.log' for more details." >&2;}+ { (exit 77); exit 77; }; }+fi++ac_exeext=$ac_cv_exeext+{ echo "$as_me:$LINENO: result: $ac_file" >&5+echo "${ECHO_T}$ac_file" >&6; }++# Check that the compiler produces executables we can run. If not, either+# the compiler is broken, or we cross compile.+{ echo "$as_me:$LINENO: checking whether the C compiler works" >&5+echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6; }+# FIXME: These cross compiler hacks should be removed for Autoconf 3.0+# If not cross compiling, check that we can run a simple program.+if test "$cross_compiling" != yes; then+ if { ac_try='./$ac_file'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ cross_compiling=no+ else+ if test "$cross_compiling" = maybe; then+ cross_compiling=yes+ else+ { { echo "$as_me:$LINENO: error: cannot run C compiled programs.+If you meant to cross compile, use \`--host'.+See \`config.log' for more details." >&5+echo "$as_me: error: cannot run C compiled programs.+If you meant to cross compile, use \`--host'.+See \`config.log' for more details." >&2;}+ { (exit 1); exit 1; }; }+ fi+ fi+fi+{ echo "$as_me:$LINENO: result: yes" >&5+echo "${ECHO_T}yes" >&6; }++rm -f a.out a.exe conftest$ac_cv_exeext b.out+ac_clean_files=$ac_clean_files_save+# Check that the compiler produces executables we can run. If not, either+# the compiler is broken, or we cross compile.+{ echo "$as_me:$LINENO: checking whether we are cross compiling" >&5+echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; }+{ echo "$as_me:$LINENO: result: $cross_compiling" >&5+echo "${ECHO_T}$cross_compiling" >&6; }++{ echo "$as_me:$LINENO: checking for suffix of executables" >&5+echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; }+if { (ac_try="$ac_link"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_link") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; then+ # If both `conftest.exe' and `conftest' are `present' (well, observable)+# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will+# work properly (i.e., refer to `conftest.exe'), while it won't with+# `rm'.+for ac_file in conftest.exe conftest conftest.*; do+ test -f "$ac_file" || continue+ case $ac_file in+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;+ *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`+ break;;+ * ) break;;+ esac+done+else+ { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link+See \`config.log' for more details." >&5+echo "$as_me: error: cannot compute suffix of executables: cannot compile and link+See \`config.log' for more details." >&2;}+ { (exit 1); exit 1; }; }+fi++rm -f conftest$ac_cv_exeext+{ echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5+echo "${ECHO_T}$ac_cv_exeext" >&6; }++rm -f conftest.$ac_ext+EXEEXT=$ac_cv_exeext+ac_exeext=$EXEEXT+{ echo "$as_me:$LINENO: checking for suffix of object files" >&5+echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; }+if test "${ac_cv_objext+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{++ ;+ return 0;+}+_ACEOF+rm -f conftest.o conftest.obj+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; then+ for ac_file in conftest.o conftest.obj conftest.*; do+ test -f "$ac_file" || continue;+ case $ac_file in+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;;+ *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`+ break;;+ esac+done+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile+See \`config.log' for more details." >&5+echo "$as_me: error: cannot compute suffix of object files: cannot compile+See \`config.log' for more details." >&2;}+ { (exit 1); exit 1; }; }+fi++rm -f conftest.$ac_cv_objext conftest.$ac_ext+fi+{ echo "$as_me:$LINENO: result: $ac_cv_objext" >&5+echo "${ECHO_T}$ac_cv_objext" >&6; }+OBJEXT=$ac_cv_objext+ac_objext=$OBJEXT+{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5+echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }+if test "${ac_cv_c_compiler_gnu+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{+#ifndef __GNUC__+ choke me+#endif++ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } &&+ { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; } &&+ { ac_try='test -s conftest.$ac_objext'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ ac_compiler_gnu=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ ac_compiler_gnu=no+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+ac_cv_c_compiler_gnu=$ac_compiler_gnu++fi+{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5+echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }+GCC=`test $ac_compiler_gnu = yes && echo yes`+ac_test_CFLAGS=${CFLAGS+set}+ac_save_CFLAGS=$CFLAGS+{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5+echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }+if test "${ac_cv_prog_cc_g+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ ac_save_c_werror_flag=$ac_c_werror_flag+ ac_c_werror_flag=yes+ ac_cv_prog_cc_g=no+ CFLAGS="-g"+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{++ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } &&+ { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; } &&+ { ac_try='test -s conftest.$ac_objext'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ ac_cv_prog_cc_g=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ CFLAGS=""+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{++ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } &&+ { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; } &&+ { ac_try='test -s conftest.$ac_objext'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ :+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ ac_c_werror_flag=$ac_save_c_werror_flag+ CFLAGS="-g"+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{++ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } &&+ { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; } &&+ { ac_try='test -s conftest.$ac_objext'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ ac_cv_prog_cc_g=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5+++fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+ ac_c_werror_flag=$ac_save_c_werror_flag+fi+{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5+echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }+if test "$ac_test_CFLAGS" = set; then+ CFLAGS=$ac_save_CFLAGS+elif test $ac_cv_prog_cc_g = yes; then+ if test "$GCC" = yes; then+ CFLAGS="-g -O2"+ else+ CFLAGS="-g"+ fi+else+ if test "$GCC" = yes; then+ CFLAGS="-O2"+ else+ CFLAGS=+ fi+fi+{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5+echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }+if test "${ac_cv_prog_cc_c89+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ ac_cv_prog_cc_c89=no+ac_save_CC=$CC+cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <stdarg.h>+#include <stdio.h>+#include <sys/types.h>+#include <sys/stat.h>+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */+struct buf { int x; };+FILE * (*rcsopen) (struct buf *, struct stat *, int);+static char *e (p, i)+ char **p;+ int i;+{+ return p[i];+}+static char *f (char * (*g) (char **, int), char **p, ...)+{+ char *s;+ va_list v;+ va_start (v,p);+ s = g (p, va_arg (v,int));+ va_end (v);+ return s;+}++/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has+ function prototypes and stuff, but not '\xHH' hex character constants.+ These don't provoke an error unfortunately, instead are silently treated+ as 'x'. The following induces an error, until -std is added to get+ proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an+ array size at least. It's necessary to write '\x00'==0 to get something+ that's true only with -std. */+int osf4_cc_array ['\x00' == 0 ? 1 : -1];++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters+ inside strings and character constants. */+#define FOO(x) 'x'+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];++int test (int i, double x);+struct s1 {int (*f) (int a);};+struct s2 {int (*f) (double a);};+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);+int argc;+char **argv;+int+main ()+{+return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];+ ;+ return 0;+}+_ACEOF+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \+ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"+do+ CC="$ac_save_CC $ac_arg"+ rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } &&+ { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; } &&+ { ac_try='test -s conftest.$ac_objext'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ ac_cv_prog_cc_c89=$ac_arg+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5+++fi++rm -f core conftest.err conftest.$ac_objext+ test "x$ac_cv_prog_cc_c89" != "xno" && break+done+rm -f conftest.$ac_ext+CC=$ac_save_CC++fi+# AC_CACHE_VAL+case "x$ac_cv_prog_cc_c89" in+ x)+ { echo "$as_me:$LINENO: result: none needed" >&5+echo "${ECHO_T}none needed" >&6; } ;;+ xno)+ { echo "$as_me:$LINENO: result: unsupported" >&5+echo "${ECHO_T}unsupported" >&6; } ;;+ *)+ CC="$CC $ac_cv_prog_cc_c89"+ { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5+echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;+esac+++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+{ echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5+echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; }+# On Suns, sometimes $CPP names a directory.+if test -n "$CPP" && test -d "$CPP"; then+ CPP=+fi+if test -z "$CPP"; then+ if test "${ac_cv_prog_CPP+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ # Double quotes because CPP needs to be expanded+ for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"+ do+ ac_preproc_ok=false+for ac_c_preproc_warn_flag in '' yes+do+ # Use a header file that comes with gcc, so configuring glibc+ # with a fresh cross-compiler works.+ # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since+ # <limits.h> exists even on freestanding compilers.+ # On the NeXT, cc -E runs the code through the compiler's parser,+ # not just through cpp. "Syntax error" is here to catch this case.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#ifdef __STDC__+# include <limits.h>+#else+# include <assert.h>+#endif+ Syntax error+_ACEOF+if { (ac_try="$ac_cpp conftest.$ac_ext"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } >/dev/null; then+ if test -s conftest.err; then+ ac_cpp_err=$ac_c_preproc_warn_flag+ ac_cpp_err=$ac_cpp_err$ac_c_werror_flag+ else+ ac_cpp_err=+ fi+else+ ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+ :+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ # Broken: fails on valid input.+continue+fi++rm -f conftest.err conftest.$ac_ext++ # OK, works on sane cases. Now check whether nonexistent headers+ # can be detected and how.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <ac_nonexistent.h>+_ACEOF+if { (ac_try="$ac_cpp conftest.$ac_ext"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } >/dev/null; then+ if test -s conftest.err; then+ ac_cpp_err=$ac_c_preproc_warn_flag+ ac_cpp_err=$ac_cpp_err$ac_c_werror_flag+ else+ ac_cpp_err=+ fi+else+ ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+ # Broken: success on invalid input.+continue+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ # Passes both tests.+ac_preproc_ok=:+break+fi++rm -f conftest.err conftest.$ac_ext++done+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.+rm -f conftest.err conftest.$ac_ext+if $ac_preproc_ok; then+ break+fi++ done+ ac_cv_prog_CPP=$CPP++fi+ CPP=$ac_cv_prog_CPP+else+ ac_cv_prog_CPP=$CPP+fi+{ echo "$as_me:$LINENO: result: $CPP" >&5+echo "${ECHO_T}$CPP" >&6; }+ac_preproc_ok=false+for ac_c_preproc_warn_flag in '' yes+do+ # Use a header file that comes with gcc, so configuring glibc+ # with a fresh cross-compiler works.+ # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since+ # <limits.h> exists even on freestanding compilers.+ # On the NeXT, cc -E runs the code through the compiler's parser,+ # not just through cpp. "Syntax error" is here to catch this case.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#ifdef __STDC__+# include <limits.h>+#else+# include <assert.h>+#endif+ Syntax error+_ACEOF+if { (ac_try="$ac_cpp conftest.$ac_ext"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } >/dev/null; then+ if test -s conftest.err; then+ ac_cpp_err=$ac_c_preproc_warn_flag+ ac_cpp_err=$ac_cpp_err$ac_c_werror_flag+ else+ ac_cpp_err=+ fi+else+ ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+ :+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ # Broken: fails on valid input.+continue+fi++rm -f conftest.err conftest.$ac_ext++ # OK, works on sane cases. Now check whether nonexistent headers+ # can be detected and how.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <ac_nonexistent.h>+_ACEOF+if { (ac_try="$ac_cpp conftest.$ac_ext"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } >/dev/null; then+ if test -s conftest.err; then+ ac_cpp_err=$ac_c_preproc_warn_flag+ ac_cpp_err=$ac_cpp_err$ac_c_werror_flag+ else+ ac_cpp_err=+ fi+else+ ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+ # Broken: success on invalid input.+continue+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ # Passes both tests.+ac_preproc_ok=:+break+fi++rm -f conftest.err conftest.$ac_ext++done+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.+rm -f conftest.err conftest.$ac_ext+if $ac_preproc_ok; then+ :+else+ { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check+See \`config.log' for more details." >&5+echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check+See \`config.log' for more details." >&2;}+ { (exit 1); exit 1; }; }+fi++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+++{ echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5+echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; }+if test "${ac_cv_path_GREP+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ # Extract the first word of "grep ggrep" to use in msg output+if test -z "$GREP"; then+set dummy grep ggrep; ac_prog_name=$2+if test "${ac_cv_path_GREP+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ ac_path_GREP_found=false+# Loop through the user's path and test for each of PROGNAME-LIST+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_prog in grep ggrep; do+ for ac_exec_ext in '' $ac_executable_extensions; do+ ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"+ { test -f "$ac_path_GREP" && $as_executable_p "$ac_path_GREP"; } || continue+ # Check for GNU ac_path_GREP and select it if it is found.+ # Check for GNU $ac_path_GREP+case `"$ac_path_GREP" --version 2>&1` in+*GNU*)+ ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;+*)+ ac_count=0+ echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"+ while :+ do+ cat "conftest.in" "conftest.in" >"conftest.tmp"+ mv "conftest.tmp" "conftest.in"+ cp "conftest.in" "conftest.nl"+ echo 'GREP' >> "conftest.nl"+ "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break+ diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break+ ac_count=`expr $ac_count + 1`+ if test $ac_count -gt ${ac_path_GREP_max-0}; then+ # Best one so far, save it but keep looking for a better one+ ac_cv_path_GREP="$ac_path_GREP"+ ac_path_GREP_max=$ac_count+ fi+ # 10*(2^10) chars as input seems more than enough+ test $ac_count -gt 10 && break+ done+ rm -f conftest.in conftest.tmp conftest.nl conftest.out;;+esac+++ $ac_path_GREP_found && break 3+ done+done++done+IFS=$as_save_IFS+++fi++GREP="$ac_cv_path_GREP"+if test -z "$GREP"; then+ { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5+echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}+ { (exit 1); exit 1; }; }+fi++else+ ac_cv_path_GREP=$GREP+fi+++fi+{ echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5+echo "${ECHO_T}$ac_cv_path_GREP" >&6; }+ GREP="$ac_cv_path_GREP"+++{ echo "$as_me:$LINENO: checking for egrep" >&5+echo $ECHO_N "checking for egrep... $ECHO_C" >&6; }+if test "${ac_cv_path_EGREP+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if echo a | $GREP -E '(a|b)' >/dev/null 2>&1+ then ac_cv_path_EGREP="$GREP -E"+ else+ # Extract the first word of "egrep" to use in msg output+if test -z "$EGREP"; then+set dummy egrep; ac_prog_name=$2+if test "${ac_cv_path_EGREP+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ ac_path_EGREP_found=false+# Loop through the user's path and test for each of PROGNAME-LIST+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_prog in egrep; do+ for ac_exec_ext in '' $ac_executable_extensions; do+ ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"+ { test -f "$ac_path_EGREP" && $as_executable_p "$ac_path_EGREP"; } || continue+ # Check for GNU ac_path_EGREP and select it if it is found.+ # Check for GNU $ac_path_EGREP+case `"$ac_path_EGREP" --version 2>&1` in+*GNU*)+ ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;+*)+ ac_count=0+ echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"+ while :+ do+ cat "conftest.in" "conftest.in" >"conftest.tmp"+ mv "conftest.tmp" "conftest.in"+ cp "conftest.in" "conftest.nl"+ echo 'EGREP' >> "conftest.nl"+ "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break+ diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break+ ac_count=`expr $ac_count + 1`+ if test $ac_count -gt ${ac_path_EGREP_max-0}; then+ # Best one so far, save it but keep looking for a better one+ ac_cv_path_EGREP="$ac_path_EGREP"+ ac_path_EGREP_max=$ac_count+ fi+ # 10*(2^10) chars as input seems more than enough+ test $ac_count -gt 10 && break+ done+ rm -f conftest.in conftest.tmp conftest.nl conftest.out;;+esac+++ $ac_path_EGREP_found && break 3+ done+done++done+IFS=$as_save_IFS+++fi++EGREP="$ac_cv_path_EGREP"+if test -z "$EGREP"; then+ { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5+echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}+ { (exit 1); exit 1; }; }+fi++else+ ac_cv_path_EGREP=$EGREP+fi+++ fi+fi+{ echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5+echo "${ECHO_T}$ac_cv_path_EGREP" >&6; }+ EGREP="$ac_cv_path_EGREP"+++{ echo "$as_me:$LINENO: checking for ANSI C header files" >&5+echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }+if test "${ac_cv_header_stdc+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <stdlib.h>+#include <stdarg.h>+#include <string.h>+#include <float.h>++int+main ()+{++ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } &&+ { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; } &&+ { ac_try='test -s conftest.$ac_objext'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ ac_cv_header_stdc=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ ac_cv_header_stdc=no+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext++if test $ac_cv_header_stdc = yes; then+ # SunOS 4.x string.h does not declare mem*, contrary to ANSI.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <string.h>++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+ $EGREP "memchr" >/dev/null 2>&1; then+ :+else+ ac_cv_header_stdc=no+fi+rm -f conftest*++fi++if test $ac_cv_header_stdc = yes; then+ # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <stdlib.h>++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+ $EGREP "free" >/dev/null 2>&1; then+ :+else+ ac_cv_header_stdc=no+fi+rm -f conftest*++fi++if test $ac_cv_header_stdc = yes; then+ # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.+ if test "$cross_compiling" = yes; then+ :+else+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <ctype.h>+#include <stdlib.h>+#if ((' ' & 0x0FF) == 0x020)+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))+#else+# define ISLOWER(c) \+ (('a' <= (c) && (c) <= 'i') \+ || ('j' <= (c) && (c) <= 'r') \+ || ('s' <= (c) && (c) <= 'z'))+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))+#endif++#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))+int+main ()+{+ int i;+ for (i = 0; i < 256; i++)+ if (XOR (islower (i), ISLOWER (i))+ || toupper (i) != TOUPPER (i))+ return 2;+ return 0;+}+_ACEOF+rm -f conftest$ac_exeext+if { (ac_try="$ac_link"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_link") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } && { ac_try='./conftest$ac_exeext'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ :+else+ echo "$as_me: program exited with status $ac_status" >&5+echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++( exit $ac_status )+ac_cv_header_stdc=no+fi+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext+fi+++fi+fi+{ echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5+echo "${ECHO_T}$ac_cv_header_stdc" >&6; }+if test $ac_cv_header_stdc = yes; then++cat >>confdefs.h <<\_ACEOF+#define STDC_HEADERS 1+_ACEOF++fi++# On IRIX 5.3, sys/types and inttypes.h are conflicting.++++++++++for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \+ inttypes.h stdint.h unistd.h+do+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`+{ echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }+if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+$ac_includes_default++#include <$ac_header>+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } &&+ { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; } &&+ { ac_try='test -s conftest.$ac_objext'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ eval "$as_ac_Header=yes"+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ eval "$as_ac_Header=no"+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+fi+ac_res=`eval echo '${'$as_ac_Header'}'`+ { echo "$as_me:$LINENO: result: $ac_res" >&5+echo "${ECHO_T}$ac_res" >&6; }+if test `eval echo '${'$as_ac_Header'}'` = yes; then+ cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1+_ACEOF++fi++done++++for ac_header in svn_error.h+do+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`+if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then+ { echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }+if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+fi+ac_res=`eval echo '${'$as_ac_Header'}'`+ { echo "$as_me:$LINENO: result: $ac_res" >&5+echo "${ECHO_T}$ac_res" >&6; }+else+ # Is the header compilable?+{ echo "$as_me:$LINENO: checking $ac_header usability" >&5+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }+cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+$ac_includes_default+#include <$ac_header>+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } &&+ { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; } &&+ { ac_try='test -s conftest.$ac_objext'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ ac_header_compiler=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ ac_header_compiler=no+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5+echo "${ECHO_T}$ac_header_compiler" >&6; }++# Is the header present?+{ echo "$as_me:$LINENO: checking $ac_header presence" >&5+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }+cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <$ac_header>+_ACEOF+if { (ac_try="$ac_cpp conftest.$ac_ext"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } >/dev/null; then+ if test -s conftest.err; then+ ac_cpp_err=$ac_c_preproc_warn_flag+ ac_cpp_err=$ac_cpp_err$ac_c_werror_flag+ else+ ac_cpp_err=+ fi+else+ ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+ ac_header_preproc=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ ac_header_preproc=no+fi++rm -f conftest.err conftest.$ac_ext+{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5+echo "${ECHO_T}$ac_header_preproc" >&6; }++# So? What about this header?+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in+ yes:no: )+ { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}+ ac_header_preproc=yes+ ;;+ no:yes:* )+ { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5+echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5+echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}++ ;;+esac+{ echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }+if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ eval "$as_ac_Header=\$ac_header_preproc"+fi+ac_res=`eval echo '${'$as_ac_Header'}'`+ { echo "$as_me:$LINENO: result: $ac_res" >&5+echo "${ECHO_T}$ac_res" >&6; }++fi+if test `eval echo '${'$as_ac_Header'}'` = yes; then+ cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1+_ACEOF++else+ { { echo "$as_me:$LINENO: error: SVN headers are required. Hint: EXTRA_CPPFLAGS" >&5+echo "$as_me: error: SVN headers are required. Hint: EXTRA_CPPFLAGS" >&2;}+ { (exit 1); exit 1; }; }+fi++done++++{ echo "$as_me:$LINENO: checking for svn_error_clear in -lsvn_subr-1" >&5+echo $ECHO_N "checking for svn_error_clear in -lsvn_subr-1... $ECHO_C" >&6; }+if test "${ac_cv_lib_svn_subr_1_svn_error_clear+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ ac_check_lib_save_LIBS=$LIBS+LIBS="-lsvn_subr-1 $LIBS"+cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++/* Override any GCC internal prototype to avoid an error.+ Use char because int might match the return type of a GCC+ builtin and then its argument prototype would still apply. */+#ifdef __cplusplus+extern "C"+#endif+char svn_error_clear ();+int+main ()+{+return svn_error_clear ();+ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext conftest$ac_exeext+if { (ac_try="$ac_link"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_link") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } &&+ { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; } &&+ { ac_try='test -s conftest$ac_exeext'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ ac_cv_lib_svn_subr_1_svn_error_clear=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ ac_cv_lib_svn_subr_1_svn_error_clear=no+fi++rm -f core conftest.err conftest.$ac_objext \+ conftest$ac_exeext conftest.$ac_ext+LIBS=$ac_check_lib_save_LIBS+fi+{ echo "$as_me:$LINENO: result: $ac_cv_lib_svn_subr_1_svn_error_clear" >&5+echo "${ECHO_T}$ac_cv_lib_svn_subr_1_svn_error_clear" >&6; }+if test $ac_cv_lib_svn_subr_1_svn_error_clear = yes; then+ cat >>confdefs.h <<_ACEOF+#define HAVE_LIBSVN_SUBR_1 1+_ACEOF++ LIBS="-lsvn_subr-1 $LIBS"++else+ { { echo "$as_me:$LINENO: error: SVN libraries are required. Hint: EXTRA_LDFLAGS" >&5+echo "$as_me: error: SVN libraries are required. Hint: EXTRA_LDFLAGS" >&2;}+ { (exit 1); exit 1; }; }+fi++++for ac_prog in apr-config+do+ # Extract the first word of "$ac_prog", so it can be a program name with args.+set dummy $ac_prog; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_APR_CONFIG+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$APR_CONFIG"; then+ ac_cv_prog_APR_CONFIG="$APR_CONFIG" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then+ ac_cv_prog_APR_CONFIG="$ac_prog"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++fi+fi+APR_CONFIG=$ac_cv_prog_APR_CONFIG+if test -n "$APR_CONFIG"; then+ { echo "$as_me:$LINENO: result: $APR_CONFIG" >&5+echo "${ECHO_T}$APR_CONFIG" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++ test -n "$APR_CONFIG" && break+done+test -n "$APR_CONFIG" || APR_CONFIG="{ { echo "$as_me:$LINENO: error: apr-config is required. Hint: APR_CONFIG" >&5+echo "$as_me: error: apr-config is required. Hint: APR_CONFIG" >&2;}+ { (exit 1); exit 1; }; }"++SVN_CFLAGS=`$APR_CONFIG --includes --cppflags`" $SVN_CFLAGS"+SVN_LIBS=`$APR_CONFIG --link-ld --libs`" $SVN_LIBS"+#+# Done the ugly checks+#++ac_config_files="$ac_config_files HsSVN.buildinfo"++cat >confcache <<\_ACEOF+# This file is a shell script that caches the results of configure+# tests run on this system so they can be shared between configure+# scripts and configure runs, see configure's option --config-cache.+# It is not useful on other systems. If it contains results you don't+# want to keep, you may remove or edit it.+#+# config.status only pays attention to the cache file if you give it+# the --recheck option to rerun configure.+#+# `ac_cv_env_foo' variables (set or unset) will be overridden when+# loading this file, other *unset* `ac_cv_foo' will be assigned the+# following values.++_ACEOF++# The following way of writing the cache mishandles newlines in values,+# but we know of no workaround that is simple, portable, and efficient.+# So, we kill variables containing newlines.+# Ultrix sh set writes to stderr and can't be redirected directly,+# and sets the high bit in the cache file unless we assign to the vars.+(+ for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do+ eval ac_val=\$$ac_var+ case $ac_val in #(+ *${as_nl}*)+ case $ac_var in #(+ *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5+echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;+ esac+ case $ac_var in #(+ _ | IFS | as_nl) ;; #(+ *) $as_unset $ac_var ;;+ esac ;;+ esac+ done++ (set) 2>&1 |+ case $as_nl`(ac_space=' '; set) 2>&1` in #(+ *${as_nl}ac_space=\ *)+ # `set' does not quote correctly, so add quotes (double-quote+ # substitution turns \\\\ into \\, and sed turns \\ into \).+ sed -n \+ "s/'/'\\\\''/g;+ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"+ ;; #(+ *)+ # `set' quotes correctly as required by POSIX, so do not add quotes.+ sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"+ ;;+ esac |+ sort+) |+ sed '+ /^ac_cv_env_/b end+ t clear+ :clear+ s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/+ t end+ s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/+ :end' >>confcache+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else+ if test -w "$cache_file"; then+ test "x$cache_file" != "x/dev/null" &&+ { echo "$as_me:$LINENO: updating cache $cache_file" >&5+echo "$as_me: updating cache $cache_file" >&6;}+ cat confcache >$cache_file+ else+ { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5+echo "$as_me: not updating unwritable cache $cache_file" >&6;}+ fi+fi+rm -f confcache++test "x$prefix" = xNONE && prefix=$ac_default_prefix+# Let make expand exec_prefix.+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'++# Transform confdefs.h into DEFS.+# Protect against shell expansion while executing Makefile rules.+# Protect against Makefile macro expansion.+#+# If the first sed substitution is executed (which looks for macros that+# take arguments), then branch to the quote section. Otherwise,+# look for a macro that doesn't take arguments.+ac_script='+t clear+:clear+s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g+t quote+s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g+t quote+b any+:quote+s/[ `~#$^&*(){}\\|;'\''"<>?]/\\&/g+s/\[/\\&/g+s/\]/\\&/g+s/\$/$$/g+H+:any+${+ g+ s/^\n//+ s/\n/ /g+ p+}+'+DEFS=`sed -n "$ac_script" confdefs.h`+++ac_libobjs=+ac_ltlibobjs=+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue+ # 1. Remove the extension, and $U if already installed.+ ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'+ ac_i=`echo "$ac_i" | sed "$ac_script"`+ # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR+ # will be set to the directory where LIBOBJS objects are built.+ ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"+ ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'+done+LIBOBJS=$ac_libobjs++LTLIBOBJS=$ac_ltlibobjs++++: ${CONFIG_STATUS=./config.status}+ac_clean_files_save=$ac_clean_files+ac_clean_files="$ac_clean_files $CONFIG_STATUS"+{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5+echo "$as_me: creating $CONFIG_STATUS" >&6;}+cat >$CONFIG_STATUS <<_ACEOF+#! $SHELL+# Generated by $as_me.+# Run this file to recreate the current configuration.+# Compiler output produced by configure, useful for debugging+# configure, is in config.log if it exists.++debug=false+ac_cs_recheck=false+ac_cs_silent=false+SHELL=\${CONFIG_SHELL-$SHELL}+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+## --------------------- ##+## M4sh Initialization. ##+## --------------------- ##++# Be Bourne compatible+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+ emulate sh+ NULLCMD=:+ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+ # is contrary to our usage. Disable this feature.+ alias -g '${1+"$@"}'='"$@"'+ setopt NO_GLOB_SUBST+else+ case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac+fi+BIN_SH=xpg4; export BIN_SH # for Tru64+DUALCASE=1; export DUALCASE # for MKS sh+++# PATH needs CR+# Avoid depending upon Character Ranges.+as_cr_letters='abcdefghijklmnopqrstuvwxyz'+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'+as_cr_Letters=$as_cr_letters$as_cr_LETTERS+as_cr_digits='0123456789'+as_cr_alnum=$as_cr_Letters$as_cr_digits++# The user is always right.+if test "${PATH_SEPARATOR+set}" != set; then+ echo "#! /bin/sh" >conf$$.sh+ echo "exit 0" >>conf$$.sh+ chmod +x conf$$.sh+ if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then+ PATH_SEPARATOR=';'+ else+ PATH_SEPARATOR=:+ fi+ rm -f conf$$.sh+fi++# Support unset when possible.+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then+ as_unset=unset+else+ as_unset=false+fi+++# IFS+# We need space, tab and new line, in precisely that order. Quoting is+# there to prevent editors from complaining about space-tab.+# (If _AS_PATH_WALK were called with IFS unset, it would disable word+# splitting by setting IFS to empty value.)+as_nl='+'+IFS=" "" $as_nl"++# Find who we are. Look in the path if we contain no directory separator.+case $0 in+ *[\\/]* ) as_myself=$0 ;;+ *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break+done+IFS=$as_save_IFS++ ;;+esac+# We did not find ourselves, most probably we were run as `sh COMMAND'+# in which case we are not to be found in the path.+if test "x$as_myself" = x; then+ as_myself=$0+fi+if test ! -f "$as_myself"; then+ echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2+ { (exit 1); exit 1; }+fi++# Work around bugs in pre-3.0 UWIN ksh.+for as_var in ENV MAIL MAILPATH+do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+done+PS1='$ '+PS2='> '+PS4='+ '++# NLS nuisances.+for as_var in \+ LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \+ LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \+ LC_TELEPHONE LC_TIME+do+ if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then+ eval $as_var=C; export $as_var+ else+ ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+ fi+done++# Required to use basename.+if expr a : '\(a\)' >/dev/null 2>&1 &&+ test "X`expr 00001 : '.*\(...\)'`" = X001; then+ as_expr=expr+else+ as_expr=false+fi++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then+ as_basename=basename+else+ as_basename=false+fi+++# Name of the executable.+as_me=`$as_basename -- "$0" ||+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \+ X"$0" : 'X\(//\)$' \| \+ X"$0" : 'X\(/\)' \| . 2>/dev/null ||+echo X/"$0" |+ sed '/^.*\/\([^/][^/]*\)\/*$/{+ s//\1/+ q+ }+ /^X\/\(\/\/\)$/{+ s//\1/+ q+ }+ /^X\/\(\/\).*/{+ s//\1/+ q+ }+ s/.*/./; q'`++# CDPATH.+$as_unset CDPATH++++ as_lineno_1=$LINENO+ as_lineno_2=$LINENO+ test "x$as_lineno_1" != "x$as_lineno_2" &&+ test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {++ # Create $as_me.lineno as a copy of $as_myself, but with $LINENO+ # uniformly replaced by the line number. The first 'sed' inserts a+ # line-number line after each line using $LINENO; the second 'sed'+ # does the real work. The second script uses 'N' to pair each+ # line-number line with the line containing $LINENO, and appends+ # trailing '-' during substitution so that $LINENO is not a special+ # case at line end.+ # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the+ # scripts with optimization help from Paolo Bonzini. Blame Lee+ # E. McMahon (1931-1989) for sed's syntax. :-)+ sed -n '+ p+ /[$]LINENO/=+ ' <$as_myself |+ sed '+ s/[$]LINENO.*/&-/+ t lineno+ b+ :lineno+ N+ :loop+ s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/+ t loop+ s/-\n.*//+ ' >$as_me.lineno &&+ chmod +x "$as_me.lineno" ||+ { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2+ { (exit 1); exit 1; }; }++ # Don't try to exec as it changes $[0], causing all sort of problems+ # (the dirname of $[0] is not the place where we might find the+ # original and so on. Autoconf is especially sensitive to this).+ . "./$as_me.lineno"+ # Exit status is that of the last command.+ exit+}+++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then+ as_dirname=dirname+else+ as_dirname=false+fi++ECHO_C= ECHO_N= ECHO_T=+case `echo -n x` in+-n*)+ case `echo 'x\c'` in+ *c*) ECHO_T=' ';; # ECHO_T is single tab character.+ *) ECHO_C='\c';;+ esac;;+*)+ ECHO_N='-n';;+esac++if expr a : '\(a\)' >/dev/null 2>&1 &&+ test "X`expr 00001 : '.*\(...\)'`" = X001; then+ as_expr=expr+else+ as_expr=false+fi++rm -f conf$$ conf$$.exe conf$$.file+if test -d conf$$.dir; then+ rm -f conf$$.dir/conf$$.file+else+ rm -f conf$$.dir+ mkdir conf$$.dir+fi+echo >conf$$.file+if ln -s conf$$.file conf$$ 2>/dev/null; then+ as_ln_s='ln -s'+ # ... but there are two gotchas:+ # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.+ # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.+ # In both cases, we have to default to `cp -p'.+ ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||+ as_ln_s='cp -p'+elif ln conf$$.file conf$$ 2>/dev/null; then+ as_ln_s=ln+else+ as_ln_s='cp -p'+fi+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file+rmdir conf$$.dir 2>/dev/null++if mkdir -p . 2>/dev/null; then+ as_mkdir_p=:+else+ test -d ./-p && rmdir ./-p+ as_mkdir_p=false+fi++# Find out whether ``test -x'' works. Don't use a zero-byte file, as+# systems may use methods other than mode bits to determine executability.+cat >conf$$.file <<_ASEOF+#! /bin/sh+exit 0+_ASEOF+chmod +x conf$$.file+if test -x conf$$.file >/dev/null 2>&1; then+ as_executable_p="test -x"+else+ as_executable_p=:+fi+rm -f conf$$.file++# Sed expression to map a string onto a valid CPP name.+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"++# Sed expression to map a string onto a valid variable name.+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"+++exec 6>&1++# Save the log message, to keep $[0] and so on meaningful, and to+# report actual input values of CONFIG_FILES etc. instead of their+# values after options handling.+ac_log="+This file was extended by $as_me, which was+generated by GNU Autoconf 2.60. Invocation command line was++ CONFIG_FILES = $CONFIG_FILES+ CONFIG_HEADERS = $CONFIG_HEADERS+ CONFIG_LINKS = $CONFIG_LINKS+ CONFIG_COMMANDS = $CONFIG_COMMANDS+ $ $0 $@++on `(hostname || uname -n) 2>/dev/null | sed 1q`+"++_ACEOF++cat >>$CONFIG_STATUS <<_ACEOF+# Files that config.status was made for.+config_files="$ac_config_files"++_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+ac_cs_usage="\+\`$as_me' instantiates files from templates according to the+current configuration.++Usage: $0 [OPTIONS] [FILE]...++ -h, --help print this help, then exit+ -V, --version print version number, then exit+ -q, --quiet do not print progress messages+ -d, --debug don't remove temporary files+ --recheck update $as_me by reconfiguring in the same conditions+ --file=FILE[:TEMPLATE]+ instantiate the configuration file FILE++Configuration files:+$config_files++Report bugs to <bug-autoconf@gnu.org>."++_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+ac_cs_version="\\+config.status+configured by $0, generated by GNU Autoconf 2.60,+ with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"++Copyright (C) 2006 Free Software Foundation, Inc.+This config.status script is free software; the Free Software Foundation+gives unlimited permission to copy, distribute and modify it."++ac_pwd='$ac_pwd'+srcdir='$srcdir'+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+# If no file are specified by the user, then we need to provide default+# value. By we need to know if files were specified by the user.+ac_need_defaults=:+while test $# != 0+do+ case $1 in+ --*=*)+ ac_option=`expr "X$1" : 'X\([^=]*\)='`+ ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`+ ac_shift=:+ ;;+ *)+ ac_option=$1+ ac_optarg=$2+ ac_shift=shift+ ;;+ esac++ case $ac_option in+ # Handling of the options.+ -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)+ ac_cs_recheck=: ;;+ --version | --versio | --versi | --vers | --ver | --ve | --v | -V )+ echo "$ac_cs_version"; exit ;;+ --debug | --debu | --deb | --de | --d | -d )+ debug=: ;;+ --file | --fil | --fi | --f )+ $ac_shift+ CONFIG_FILES="$CONFIG_FILES $ac_optarg"+ ac_need_defaults=false;;+ --he | --h | --help | --hel | -h )+ echo "$ac_cs_usage"; exit ;;+ -q | -quiet | --quiet | --quie | --qui | --qu | --q \+ | -silent | --silent | --silen | --sile | --sil | --si | --s)+ ac_cs_silent=: ;;++ # This is an error.+ -*) { echo "$as_me: error: unrecognized option: $1+Try \`$0 --help' for more information." >&2+ { (exit 1); exit 1; }; } ;;++ *) ac_config_targets="$ac_config_targets $1"+ ac_need_defaults=false ;;++ esac+ shift+done++ac_configure_extra_args=++if $ac_cs_silent; then+ exec 6>/dev/null+ ac_configure_extra_args="$ac_configure_extra_args --silent"+fi++_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+if \$ac_cs_recheck; then+ echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6+ CONFIG_SHELL=$SHELL+ export CONFIG_SHELL+ exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion+fi++_ACEOF+cat >>$CONFIG_STATUS <<\_ACEOF+exec 5>>config.log+{+ echo+ sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX+## Running $as_me. ##+_ASBOX+ echo "$ac_log"+} >&5++_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF++# Handling of arguments.+for ac_config_target in $ac_config_targets+do+ case $ac_config_target in+ "HsSVN.buildinfo") CONFIG_FILES="$CONFIG_FILES HsSVN.buildinfo" ;;++ *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5+echo "$as_me: error: invalid argument: $ac_config_target" >&2;}+ { (exit 1); exit 1; }; };;+ esac+done+++# If the user did not use the arguments to specify the items to instantiate,+# then the envvar interface is used. Set only those that are not.+# We use the long form for the default assignment because of an extremely+# bizarre bug on SunOS 4.1.3.+if $ac_need_defaults; then+ test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files+fi++# Have a temporary directory for convenience. Make it in the build tree+# simply because there is no reason against having it here, and in addition,+# creating and moving files from /tmp can sometimes cause problems.+# Hook for its removal unless debugging.+# Note that there is a small window in which the directory will not be cleaned:+# after its creation but before its name has been assigned to `$tmp'.+$debug ||+{+ tmp=+ trap 'exit_status=$?+ { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status+' 0+ trap '{ (exit 1); exit 1; }' 1 2 13 15+}+# Create a (secure) tmp directory for tmp files.++{+ tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&+ test -n "$tmp" && test -d "$tmp"+} ||+{+ tmp=./conf$$-$RANDOM+ (umask 077 && mkdir "$tmp")+} ||+{+ echo "$me: cannot create a temporary directory in ." >&2+ { (exit 1); exit 1; }+}++#+# Set up the sed scripts for CONFIG_FILES section.+#++# No need to generate the scripts if there are no CONFIG_FILES.+# This happens for instance when ./config.status config.h+if test -n "$CONFIG_FILES"; then++_ACEOF++++ac_delim='%!_!# '+for ac_last_try in false false false false false :; do+ cat >conf$$subs.sed <<_ACEOF+SHELL!$SHELL$ac_delim+PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim+PACKAGE_NAME!$PACKAGE_NAME$ac_delim+PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim+PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim+PACKAGE_STRING!$PACKAGE_STRING$ac_delim+PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim+exec_prefix!$exec_prefix$ac_delim+prefix!$prefix$ac_delim+program_transform_name!$program_transform_name$ac_delim+bindir!$bindir$ac_delim+sbindir!$sbindir$ac_delim+libexecdir!$libexecdir$ac_delim+datarootdir!$datarootdir$ac_delim+datadir!$datadir$ac_delim+sysconfdir!$sysconfdir$ac_delim+sharedstatedir!$sharedstatedir$ac_delim+localstatedir!$localstatedir$ac_delim+includedir!$includedir$ac_delim+oldincludedir!$oldincludedir$ac_delim+docdir!$docdir$ac_delim+infodir!$infodir$ac_delim+htmldir!$htmldir$ac_delim+dvidir!$dvidir$ac_delim+pdfdir!$pdfdir$ac_delim+psdir!$psdir$ac_delim+libdir!$libdir$ac_delim+localedir!$localedir$ac_delim+mandir!$mandir$ac_delim+DEFS!$DEFS$ac_delim+ECHO_C!$ECHO_C$ac_delim+ECHO_N!$ECHO_N$ac_delim+ECHO_T!$ECHO_T$ac_delim+LIBS!$LIBS$ac_delim+build_alias!$build_alias$ac_delim+host_alias!$host_alias$ac_delim+target_alias!$target_alias$ac_delim+EXTRA_CPPFLAGS!$EXTRA_CPPFLAGS$ac_delim+EXTRA_LDFLAGS!$EXTRA_LDFLAGS$ac_delim+SVN_CFLAGS!$SVN_CFLAGS$ac_delim+SVN_LIBS!$SVN_LIBS$ac_delim+CC!$CC$ac_delim+CFLAGS!$CFLAGS$ac_delim+LDFLAGS!$LDFLAGS$ac_delim+CPPFLAGS!$CPPFLAGS$ac_delim+ac_ct_CC!$ac_ct_CC$ac_delim+EXEEXT!$EXEEXT$ac_delim+OBJEXT!$OBJEXT$ac_delim+CPP!$CPP$ac_delim+GREP!$GREP$ac_delim+EGREP!$EGREP$ac_delim+APR_CONFIG!$APR_CONFIG$ac_delim+LIBOBJS!$LIBOBJS$ac_delim+LTLIBOBJS!$LTLIBOBJS$ac_delim+_ACEOF++ if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 54; then+ break+ elif $ac_last_try; then+ { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5+echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}+ { (exit 1); exit 1; }; }+ else+ ac_delim="$ac_delim!$ac_delim _$ac_delim!! "+ fi+done++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`+if test -n "$ac_eof"; then+ ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`+ ac_eof=`expr $ac_eof + 1`+fi++cat >>$CONFIG_STATUS <<_ACEOF+cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end+_ACEOF+sed '+s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g+s/^/s,@/; s/!/@,|#_!!_#|/+:n+t n+s/'"$ac_delim"'$/,g/; t+s/$/\\/; p+N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n+' >>$CONFIG_STATUS <conf$$subs.sed+rm -f conf$$subs.sed+cat >>$CONFIG_STATUS <<_ACEOF+:end+s/|#_!!_#|//g+CEOF$ac_eof+_ACEOF+++# VPATH may cause trouble with some makes, so we remove $(srcdir),+# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and+# trailing colons and then remove the whole line if VPATH becomes empty+# (actually we leave an empty line to preserve line numbers).+if test "x$srcdir" = x.; then+ ac_vpsub='/^[ ]*VPATH[ ]*=/{+s/:*\$(srcdir):*/:/+s/:*\${srcdir}:*/:/+s/:*@srcdir@:*/:/+s/^\([^=]*=[ ]*\):*/\1/+s/:*$//+s/^[^=]*=[ ]*$//+}'+fi++cat >>$CONFIG_STATUS <<\_ACEOF+fi # test -n "$CONFIG_FILES"+++for ac_tag in :F $CONFIG_FILES+do+ case $ac_tag in+ :[FHLC]) ac_mode=$ac_tag; continue;;+ esac+ case $ac_mode$ac_tag in+ :[FHL]*:*);;+ :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5+echo "$as_me: error: Invalid tag $ac_tag." >&2;}+ { (exit 1); exit 1; }; };;+ :[FH]-) ac_tag=-:-;;+ :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;+ esac+ ac_save_IFS=$IFS+ IFS=:+ set x $ac_tag+ IFS=$ac_save_IFS+ shift+ ac_file=$1+ shift++ case $ac_mode in+ :L) ac_source=$1;;+ :[FH])+ ac_file_inputs=+ for ac_f+ do+ case $ac_f in+ -) ac_f="$tmp/stdin";;+ *) # Look for the file first in the build tree, then in the source tree+ # (if the path is not absolute). The absolute path cannot be DOS-style,+ # because $ac_f cannot contain `:'.+ test -f "$ac_f" ||+ case $ac_f in+ [\\/$]*) false;;+ *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;+ esac ||+ { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5+echo "$as_me: error: cannot find input file: $ac_f" >&2;}+ { (exit 1); exit 1; }; };;+ esac+ ac_file_inputs="$ac_file_inputs $ac_f"+ done++ # Let's still pretend it is `configure' which instantiates (i.e., don't+ # use $as_me), people would be surprised to read:+ # /* config.h. Generated by config.status. */+ configure_input="Generated from "`IFS=:+ echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."+ if test x"$ac_file" != x-; then+ configure_input="$ac_file. $configure_input"+ { echo "$as_me:$LINENO: creating $ac_file" >&5+echo "$as_me: creating $ac_file" >&6;}+ fi++ case $ac_tag in+ *:-:* | *:-) cat >"$tmp/stdin";;+ esac+ ;;+ esac++ ac_dir=`$as_dirname -- "$ac_file" ||+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+ X"$ac_file" : 'X\(//\)[^/]' \| \+ X"$ac_file" : 'X\(//\)$' \| \+ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||+echo X"$ac_file" |+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{+ s//\1/+ q+ }+ /^X\(\/\/\)[^/].*/{+ s//\1/+ q+ }+ /^X\(\/\/\)$/{+ s//\1/+ q+ }+ /^X\(\/\).*/{+ s//\1/+ q+ }+ s/.*/./; q'`+ { as_dir="$ac_dir"+ case $as_dir in #(+ -*) as_dir=./$as_dir;;+ esac+ test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {+ as_dirs=+ while :; do+ case $as_dir in #(+ *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(+ *) as_qdir=$as_dir;;+ esac+ as_dirs="'$as_qdir' $as_dirs"+ as_dir=`$as_dirname -- "$as_dir" ||+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+ X"$as_dir" : 'X\(//\)[^/]' \| \+ X"$as_dir" : 'X\(//\)$' \| \+ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||+echo X"$as_dir" |+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{+ s//\1/+ q+ }+ /^X\(\/\/\)[^/].*/{+ s//\1/+ q+ }+ /^X\(\/\/\)$/{+ s//\1/+ q+ }+ /^X\(\/\).*/{+ s//\1/+ q+ }+ s/.*/./; q'`+ test -d "$as_dir" && break+ done+ test -z "$as_dirs" || eval "mkdir $as_dirs"+ } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5+echo "$as_me: error: cannot create directory $as_dir" >&2;}+ { (exit 1); exit 1; }; }; }+ ac_builddir=.++case "$ac_dir" in+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;+*)+ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`+ # A ".." for each directory in $ac_dir_suffix.+ ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`+ case $ac_top_builddir_sub in+ "") ac_top_builddir_sub=. ac_top_build_prefix= ;;+ *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;+ esac ;;+esac+ac_abs_top_builddir=$ac_pwd+ac_abs_builddir=$ac_pwd$ac_dir_suffix+# for backward compatibility:+ac_top_builddir=$ac_top_build_prefix++case $srcdir in+ .) # We are building in place.+ ac_srcdir=.+ ac_top_srcdir=$ac_top_builddir_sub+ ac_abs_top_srcdir=$ac_pwd ;;+ [\\/]* | ?:[\\/]* ) # Absolute name.+ ac_srcdir=$srcdir$ac_dir_suffix;+ ac_top_srcdir=$srcdir+ ac_abs_top_srcdir=$srcdir ;;+ *) # Relative name.+ ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix+ ac_top_srcdir=$ac_top_build_prefix$srcdir+ ac_abs_top_srcdir=$ac_pwd/$srcdir ;;+esac+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix+++ case $ac_mode in+ :F)+ #+ # CONFIG_FILE+ #++_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+# If the template does not know about datarootdir, expand it.+# FIXME: This hack should be removed a few years after 2.60.+ac_datarootdir_hack=; ac_datarootdir_seen=++case `sed -n '/datarootdir/ {+ p+ q+}+/@datadir@/p+/@docdir@/p+/@infodir@/p+/@localedir@/p+/@mandir@/p+' $ac_file_inputs` in+*datarootdir*) ac_datarootdir_seen=yes;;+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)+ { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5+echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}+_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+ ac_datarootdir_hack='+ s&@datadir@&$datadir&g+ s&@docdir@&$docdir&g+ s&@infodir@&$infodir&g+ s&@localedir@&$localedir&g+ s&@mandir@&$mandir&g+ s&\\\${datarootdir}&$datarootdir&g' ;;+esac+_ACEOF++# Neutralize VPATH when `$srcdir' = `.'.+# Shell code in configure.ac might set extrasub.+# FIXME: do we really want to maintain this feature?+cat >>$CONFIG_STATUS <<_ACEOF+ sed "$ac_vpsub+$extrasub+_ACEOF+cat >>$CONFIG_STATUS <<\_ACEOF+:t+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b+s&@configure_input@&$configure_input&;t t+s&@top_builddir@&$ac_top_builddir_sub&;t t+s&@srcdir@&$ac_srcdir&;t t+s&@abs_srcdir@&$ac_abs_srcdir&;t t+s&@top_srcdir@&$ac_top_srcdir&;t t+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t+s&@builddir@&$ac_builddir&;t t+s&@abs_builddir@&$ac_abs_builddir&;t t+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t+$ac_datarootdir_hack+" $ac_file_inputs | sed -f "$tmp/subs-1.sed" >$tmp/out++test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&+ { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&+ { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&+ { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'+which seems to be undefined. Please make sure it is defined." >&5+echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'+which seems to be undefined. Please make sure it is defined." >&2;}++ rm -f "$tmp/stdin"+ case $ac_file in+ -) cat "$tmp/out"; rm -f "$tmp/out";;+ *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;;+ esac+ ;;++++ esac++done # for ac_tag+++{ (exit 0); exit 0; }+_ACEOF+chmod +x $CONFIG_STATUS+ac_clean_files=$ac_clean_files_save+++# configure is writing to config.log, and then calls config.status.+# config.status does its own redirection, appending to config.log.+# Unfortunately, on DOS this fails, as config.log is still kept open+# by configure, so config.status won't be able to write to it; its+# output is simply discarded. So we exec the FD to /dev/null,+# effectively closing config.log, so it can be properly (re)opened and+# appended to by config.status. When coming back to configure, we+# need to make the FD available again.+if test "$no_create" != yes; then+ ac_cs_success=:+ ac_config_status_args=+ test "$silent" = yes &&+ ac_config_status_args="$ac_config_status_args --quiet"+ exec 5>/dev/null+ $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false+ exec 5>>config.log+ # Use ||, not &&, to avoid exiting from the if with $? = 1, which+ # would make configure fail if this is the last instruction.+ $ac_cs_success || { (exit 1); exit 1; }+fi
+ configure.ac view
@@ -0,0 +1,46 @@+AC_INIT([HsSVN], [], [phonohawk@ps.sakura.ne.jp])++AC_CONFIG_SRCDIR([HsSVN.cabal])++#+# Checks for Subversion...+#+# FIXME: we can get rid of these ugly checks when we got svn-config or+# something alike.+#+AC_ARG_VAR([EXTRA_CPPFLAGS], [extra CPPFLAGS to find subversion])+AC_ARG_VAR([EXTRA_LDFLAGS], [extra LDFLAGS to find subversion])+CPPFLAGS="$EXTRA_CPPFLAGS $CPPFLAGS"+LDFLAGS="$EXTRA_LDFLAGS $LDFLAGS"++SVN_CFLAGS="$EXTRA_CPPFLAGS"+SVN_LIBS="$EXTRA_LIBS -lsvn_subr-1 -lsvn_repos-1 -lsvn_fs-1"+AC_SUBST([SVN_CFLAGS])+AC_SUBST([SVN_LIBS])++AC_CHECK_HEADERS(+ [svn_error.h],+ [],+ [AC_MSG_ERROR([SVN headers are required. Hint: EXTRA_CPPFLAGS])])++AC_CHECK_LIB(+ [svn_subr-1],+ [svn_error_clear],+ [],+ [AC_MSG_ERROR([SVN libraries are required. Hint: EXTRA_LDFLAGS])])++AC_ARG_VAR([APR_CONFIG], [apr-config to use])+AC_CHECK_PROGS(+ [APR_CONFIG],+ [apr-config],+ [AC_MSG_ERROR([apr-config is required. Hint: APR_CONFIG])])+SVN_CFLAGS=`$APR_CONFIG --includes --cppflags`" $SVN_CFLAGS"+SVN_LIBS=`$APR_CONFIG --link-ld --libs`" $SVN_LIBS"+#+# Done the ugly checks+#++AC_CONFIG_FILES([+ HsSVN.buildinfo+])+AC_OUTPUT
+ examples/HelloWorld.hs view
@@ -0,0 +1,32 @@+import Subversion+import Subversion.Repository+import Subversion.FileSystem+import Subversion.FileSystem.Revision+import Subversion.FileSystem.Root+import Subversion.FileSystem.Transaction++main = withSubversion $+ do putStrLn "Creating a repository \"repos\"..."+ repos <- createRepository "repos" [] []+ fs <- getRepositoryFS repos+++ rev <- getYoungestRev fs+ putStrLn ("The youngest revision of the repository is " ++ show rev)+++ putStrLn "Storing a file \"/hello\" in it..."+ Right newRev <- doReposTxn repos rev "HelloWorld" (Just "New file: /hello")+ $ do makeFile "/hello"+ applyText "/hello" Nothing "Hello, world!"+ putStrLn ("Succeeded. The revision is " ++ show newRev ++ ".")+++ putStrLn ("Getting the content of \"/hello\" at revision " ++ show newRev ++ "...")+ content <- withRevision fs newRev+ $ getFileContents "/hello"+ putStrLn ("-------------\n" ++ content ++ "\n-------------")+ + + putStrLn "Deleting the repository..."+ deleteRepository "repos"
+ examples/Makefile view
@@ -0,0 +1,12 @@+GHCFLAGS = -fglasgow-exts++build:+ ghc $(GHCFLAGS) --make HelloWorld++run: build+ ./HelloWorld++clean:+ rm -f HelloWorld *.hi *.o++.PHONY: build run clean