packages feed

cublas 0.2.1.0 → 0.3.0.0

raw patch · 30 files changed

+2064/−9486 lines, 30 filesdep +halfdep −filepathdep −language-cdep −template-haskelldep ~basedep ~cudadep ~storable-complexsetup-changednew-uploader

Dependencies added: half

Dependencies removed: filepath, language-c, template-haskell

Dependency ranges changed: base, cuda, storable-complex

Files

+ CHANGELOG.md view
@@ -0,0 +1,10 @@+# Revision history for cublas++Notable changes to the project will be documented in this file.++The format is based on [Keep a Changelog](http://keepachangelog.com/).++## 0.3.0.0 - 2017-08-24++* First version; replaces [bmsherman/cublas](https://github.com/bmsherman/cublas). Released on an unsuspecting world.+
+ Foreign/CUDA/BLAS.hs view
@@ -0,0 +1,134 @@+-- |+-- Module      : Foreign.CUDA.BLAS+-- Copyright   : [2014..2017] Trevor L. McDonell+-- License     : BSD3+--+-- Maintainer  : Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>+-- Stability   : experimental+-- Portability : non-portable (GHC extensions)+--+-- The cuBLAS library is an implementation of BLAS (Basic Linear Algebra+-- Subprograms) for NVIDIA GPUs.+--+-- To use operations from the cuBLAS library, the user must allocate the+-- required matrices and vectors in the GPU memory space, fill them with data,+-- call the desired sequence of cuBLAS functions, then copy the results from the+-- GPU memory space back to the host.+--+-- The <http://hackage.haskell.org/package/cuda cuda> package can be used for+-- writing to and retrieving data from the GPU.+--+-- [/Data layout/]+--+-- Unlike modern BLAS libraries, cuBLAS /only/ provides Fortran-style+-- implementations of the subprograms, using column-major storage and 1-based+-- indexing.+--+-- The @<http://docs.nvidia.com/cuda/cublas/index.html#cublas-lt-t-gt-geam ?geam>@+-- operation can be used to perform matrix transposition.+--+-- [/Example/]+--+-- At a short example, we show how to compute the following matrix-matrix+-- product with 'dgemm':+--+-- \[+-- \left(\begin{matrix} 1 & 2 \\ 3 & 4 \\ 5 & 6 \\ \end{matrix}\right) \cdot+-- \left(\begin{matrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ \end{matrix}\right)  =+-- \left(\begin{matrix} 9 & 12 & 15 \\ 19 & 26 & 33 \\ 29 & 40 & 51 \\ \end{matrix}\right)+-- \]+--+-- I assume you know how to initialise the CUDA+-- environment, as described in the "Foreign.CUDA.Driver" module:+--+-- >>> import Foreign.CUDA.Driver as CUDA+-- >>> import Foreign.CUDA.BLAS as BLAS+-- >>> CUDA.initialise []+-- >>> dev <- CUDA.device 0+-- >>> ctx <- CUDA.create dev []+--+-- Just as we must create a CUDA execution context with+-- 'Foreign.CUDA.Driver.create' before interacting with the GPU, we must create+-- a BLAS context handle before executing any cuBLAS library operations, which+-- will be associated with the current device context:+--+-- >>> hdl <- BLAS.create+--+-- Now, let us generate the matrix data on the GPU. (For simplicity in this+-- example we will just marshal the data via lists, but in a real application+-- with a large amount of data we should of course use some kind of unboxed+-- array):+--+-- >>> let rowsA = 3; colsA = 2; sizeA = rowsA * colsA+-- >>> let rowsB = 2; colsB = 3; sizeB = rowsB * colsB+-- >>> let sizeC = rowsA * colsB+-- >>> matA <- CUDA.newListArray (take sizeA [1..])+-- >>> matB <- CUDA.newListArray (take sizeB [1..])+-- >>> matC <- CUDA.mallocArray sizeC+--+-- Note in the above that we store data in row-major order, as is the convention+-- in C. However, the cuBLAS library assumes a column-major representation, as+-- is the style of Fortran. However, we can make use of the following+-- equivalency:+--+-- \[+-- B^T \cdot A^T = (A \cdot B)^T+-- \]+--+-- and, since the transposed matrix in column-major representation is equivalent+-- to our matrix in row-major representation, we can avoid any actual data+-- manipulation to get things into a form suitable for cuBLAS (phew!).+--+-- The final thing to take care of are the scaling parameters to the 'dgemm'+-- operation, \(\alpha\) and \(\beta\). By default, it is assumed that these+-- values reside in host memory, but this setting can be changed with+-- 'setPointerMode'; When set to 'Device' mode, the function+-- 'Foreign.CUDA.Ptr.withDevicePtr' can be used to treat the device memory+-- pointer as a plain pointer to pass to the function.+--+-- Now, we are ready to piece it all together:+--+-- >>> import Foreign.Marshal+-- >>> with 1.0 $ \alpha ->+-- >>> with 0.0 $ \beta ->+-- >>>   dgemm hdl N N colsB rowsA colsA alpha matB colsB matA colsA beta matC colsB+--+-- And retrieve the result:+--+-- >>> print =<< CUDA.peekListArray sizeC matC+-- [9.0,12.0,15.0,19.0,26.0,33.0,29.0,40.0,51.0]+--+-- Finally, we should 'Foreign.CUDA.Driver.free' the device memory we allocated,+-- and release the BLAS context handle:+--+-- >>> BLAS.destroy hdl+--+-- [/Additional information/]+--+-- For more information, see the NVIDIA cuBLAS documentation:+--+-- <http://docs.nvidia.com/cuda/cublas/index.html>+--++module Foreign.CUDA.BLAS (++  -- * Control+  module Foreign.CUDA.BLAS.Context,+  module Foreign.CUDA.BLAS.Stream,+  module Foreign.CUDA.BLAS.Error,++  -- * Operations+  module Foreign.CUDA.BLAS.Level1,+  module Foreign.CUDA.BLAS.Level2,+  module Foreign.CUDA.BLAS.Level3,++) where++import Foreign.CUDA.BLAS.Context                hiding ( useHandle )+import Foreign.CUDA.BLAS.Error                  hiding ( resultIfOk, nothingIfOk )+import Foreign.CUDA.BLAS.Stream++import Foreign.CUDA.BLAS.Level1+import Foreign.CUDA.BLAS.Level2+import Foreign.CUDA.BLAS.Level3+
+ Foreign/CUDA/BLAS/Context.chs view
@@ -0,0 +1,126 @@+{-# LANGUAGE CPP                      #-}+{-# LANGUAGE ForeignFunctionInterface #-}+-- |+-- Module      : Foreign.CUDA.BLAS.Context+-- Copyright   : [2014..2017] Trevor L. McDonell+-- License     : BSD3+--+-- Maintainer  : Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>+-- Stability   : experimental+-- Portability : non-portable (GHC extensions)+--++module Foreign.CUDA.BLAS.Context (++  -- * Context management+  Handle(..),+  create, destroy,++  -- ** Utilities+  PointerMode(..), AtomicsMode(..),+  setPointerMode,+  getPointerMode,+  setAtomicsMode,+  getAtomicsMode,++) where++-- Friends+import Foreign.CUDA.BLAS.Error+import Foreign.CUDA.BLAS.Internal.C2HS+import Foreign.CUDA.BLAS.Internal.Types++-- System+import Foreign+import Foreign.C+import Control.Monad                            ( liftM )++#include "cbits/stubs.h"+{# context lib="cublas" #}+++-- | This function initializes the CUBLAS library and creates a handle to an+-- opaque structure holding the CUBLAS library context. It allocates hardware+-- resources on the host and device and must be called prior to making any other+-- CUBLAS library calls.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublascreate>+--+{-# INLINEABLE create #-}+{# fun unsafe cublasCreate_v2 as create+  { alloca- `Handle' peekHdl* } -> `()' checkStatus*- #}+  where+    peekHdl = liftM Handle . peek+++-- | This function releases hardware resources used by the CUBLAS library. The+-- release of GPU resources may be deferred until the application exits. This+-- function is usually the last call with a particular handle to the CUBLAS+-- library.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasdestroy>+--+{-# INLINEABLE destroy #-}+{# fun unsafe cublasDestroy_v2 as destroy+  { useHandle `Handle' } -> `()' checkStatus* #}+++-- | Set the pointer mode used by cuBLAS library functions. For example, this+-- controls whether the scaling parameters \(\alpha\) and \(\beta\) of the+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublas-lt-t-gt-gemm ?gemm>+-- operation are treated as residing in host or device memory.+--+-- The default mode is for values to be passed by reference from the host.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublassetpointermode>+--+{-# INLINEABLE setPointerMode #-}+{# fun unsafe cublasSetPointerMode_v2 as setPointerMode+  { useHandle `Handle'+  , cFromEnum `PointerMode'+  }+  -> `()' checkStatus* #}++-- | Get the pointer mode used by cuBLAS library functions to pass scalar+-- arguments.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasgetpointermode>+--+{-# INLINEABLE getPointerMode #-}+{# fun unsafe cublasGetPointerMode_v2 as getPointerMode+  { useHandle `Handle'+  , alloca-   `PointerMode' peekPM*+  }+  -> `()' checkStatus*- #}+  where+    peekPM = liftM cToEnum . peek+++-- | Set whether cuBLAS library functions are allowed to use atomic functions,+-- when available. The implementations are generally faster, but can generate+-- results which are not strictly identical from one run to another.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublassetatomicsmode>+--+{-# INLINEABLE setAtomicsMode #-}+{# fun unsafe cublasSetAtomicsMode as setAtomicsMode+  { useHandle `Handle'+  , cFromEnum `AtomicsMode'+  }+  -> `()' checkStatus* #}+++-- | Determine whether cuBLAS library functions are allowed to use atomic+-- operations.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasgetatomicsmode>+--+{-# INLINEABLE getAtomicsMode #-}+{# fun unsafe cublasGetAtomicsMode as getAtomicsMode+  { useHandle `Handle'+  , alloca-   `AtomicsMode' peekAM*+  }+  -> `()' checkStatus*- #}+  where+    peekAM = liftM cToEnum . peek+
+ Foreign/CUDA/BLAS/Error.chs view
@@ -0,0 +1,98 @@+{-# LANGUAGE CPP                      #-}+{-# LANGUAGE DeriveDataTypeable       #-}+{-# LANGUAGE ForeignFunctionInterface #-}+-- |+-- Module      : Foreign.CUDA.BLAS.Error+-- Copyright   : [2014..2017] Trevor L. McDonell+-- License     : BSD3+--+-- Maintainer  : Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>+-- Stability   : experimental+-- Portability : non-portable (GHC extensions)+--++module Foreign.CUDA.BLAS.Error+  where++-- friends+import Foreign.CUDA.BLAS.Internal.C2HS++-- system+import Control.Exception+import Data.Typeable+import Foreign.C.Types++#include "cbits/stubs.h"+{# context lib="cublas" #}+++-- | Error codes used by cuBLAS library functions+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasstatus_t>+--+{# enum cublasStatus_t as Status+  { underscoreToCase }+  with prefix="CUBLAS_STATUS" deriving (Eq, Show) #}++-- Describe each error code+--+describe :: Status -> String+describe Success         = "success"+describe NotInitialized  = "library not initialised"+describe AllocFailed     = "resource allocation failed"+describe InvalidValue    = "unsupported value or parameter passed to a function"+describe ArchMismatch    = "unsupported on current architecture"+describe MappingError    = "access to GPU memory failed"+describe ExecutionFailed = "execution failed"+describe InternalError   = "internal error"+describe NotSupported    = "not supported"+#if CUDA_VERSION >= 6500+describe LicenseError    = "license error"+#endif+++-- Exceptions ------------------------------------------------------------------+--+data CUBLASException+  = ExitCode  Status+  | UserError String+  deriving Typeable++instance Exception CUBLASException++instance Show CUBLASException where+  showsPrec _ (ExitCode  s) = showString ("CUBLAS Exception: " ++ describe s)+  showsPrec _ (UserError s) = showString ("CUBLAS Exception: " ++ s)+++-- | Raise a CUBLASException in the IO Monad+--+cublasError :: String -> IO a+cublasError s = throwIO (UserError s)+++-- | Return the results of a function on successful execution, otherwise throw+-- an exception with an error string associated with the return code+--+{-# INLINE resultIfOk #-}+resultIfOk :: (Status, a) -> IO a+resultIfOk (status,result) =+    case status of+        Success -> return  result+        _       -> throwIO (ExitCode status)+++-- | Throw an exception with an error string associated with an unsuccessful+-- return code, otherwise return unit.+--+{-# INLINE nothingIfOk #-}+nothingIfOk :: Status -> IO ()+nothingIfOk status =+    case status of+        Success -> return  ()+        _       -> throwIO (ExitCode status)++{-# INLINE checkStatus #-}+checkStatus :: CInt -> IO ()+checkStatus = nothingIfOk . cToEnum+
+ Foreign/CUDA/BLAS/Internal/C2HS.hs view
@@ -0,0 +1,70 @@+-- |+-- Module      : Foreign.CUDA.BLAS.Internal.C2HS+-- Copyright   : [2014..2017] Trevor L. McDonell+-- License     : BSD3+--+-- Maintainer  : Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>+-- Stability   : experimental+-- Portability : non-portable (GHC extensions)+--++module Foreign.CUDA.BLAS.Internal.C2HS (++  -- * Conversion between C and Haskell types+  cIntConv, cFloatConv, cToBool, cFromBool, cToEnum, cFromEnum,++) where++-- system+import Foreign+import Foreign.C+++-- Conversions -----------------------------------------------------------------+--++-- | Integral conversion+--+{-# INLINE cIntConv #-}+cIntConv :: (Integral a, Integral b) => a -> b+cIntConv  = fromIntegral++-- | Floating conversion+--+{-# INLINE [1] cFloatConv #-}+cFloatConv :: (RealFloat a, RealFloat b) => a -> b+cFloatConv  = realToFrac+-- As this conversion by default goes via `Rational', it can be very slow...+{-# RULES+  "cFloatConv/Float->Float"    forall (x::Float).  cFloatConv x = x;+  "cFloatConv/Double->Double"  forall (x::Double). cFloatConv x = x;+  "cFloatConv/Float->CFloat"   forall (x::Float).  cFloatConv x = CFloat x;+  "cFloatConv/CFloat->Float"   forall (x::Float).  cFloatConv CFloat x = x;+  "cFloatConv/Double->CDouble" forall (x::Double). cFloatConv x = CDouble x;+  "cFloatConv/CDouble->Double" forall (x::Double). cFloatConv CDouble x = x+ #-}++-- | Obtain C value from Haskell 'Bool'.+--+{-# INLINE cFromBool #-}+cFromBool :: Num a => Bool -> a+cFromBool  = fromBool++-- | Obtain Haskell 'Bool' from C value.+--+{-# INLINE cToBool #-}+cToBool :: (Eq a, Num a) => a -> Bool+cToBool  = toBool++-- | Convert a C enumeration to Haskell.+--+{-# INLINE cToEnum #-}+cToEnum :: (Integral i, Enum e) => i -> e+cToEnum  = toEnum . cIntConv++-- | Convert a Haskell enumeration to C.+--+{-# INLINE cFromEnum #-}+cFromEnum :: (Enum e, Integral i) => e -> i+cFromEnum  = cIntConv . fromEnum+
+ Foreign/CUDA/BLAS/Internal/Types.chs view
@@ -0,0 +1,130 @@+{-# LANGUAGE CPP                      #-}+{-# LANGUAGE EmptyDataDecls           #-}+{-# LANGUAGE ForeignFunctionInterface #-}+-- |+-- Module      : Foreign.CUDA.BLAS.Internal.Types+-- Copyright   : [2014..2017] Trevor L. McDonell+-- License     : BSD3+--+-- Maintainer  : Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>+-- Stability   : experimental+-- Portability : non-portable (GHC extensions)+--++module Foreign.CUDA.BLAS.Internal.Types+  where++import Prelude                                            hiding ( Either(..) )+import Foreign.Ptr++#include "cbits/stubs.h"+{# context lib="cublas" #}+++-- | An opaque handle to the cuBLAS library context, which is passed to all+-- library function calls.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublashandle_t>+--+newtype Handle = Handle { useHandle :: {# type cublasHandle_t #}}+++-- | Indicates which operation needs to be performed with a dense matrix.+--+--   * @N@: no transpose selected+--   * @T@: transpose operation+--   * @C@: conjugate transpose+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasoperation_t>+--+{# enum cublasOperation_t as Operation+  { underscoreToCase }+  with prefix="CUBLAS_OP" deriving (Eq, Show) #}+++-- | Indicates which part, upper or lower, of a dense matrix was filled and+-- consequently should be used by the function.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasfillmode_t>+--+{# enum cublasFillMode_t as Fill+  { underscoreToCase }+  with prefix="CUBLAS_FILL_MODE" deriving (Eq, Show) #}+++-- | Indicates whether the main diagonal of a dense matrix is unity and+-- consequently should not be be touched or modified by the function.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasdiagtype_t>+--+{# enum cublasDiagType_t as Diagonal+  { underscoreToCase }+  with prefix="CUBLAS_DIAG" deriving (Eq, Show) #}+++-- | Indicates whether the dense matrix is on the lift or right side in the+-- matrix equation solved by a particular function.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublassidemode_t>+--+{# enum cublasSideMode_t as Side+  { underscoreToCase }+  with prefix="CUBLAS_SIDE" deriving (Eq, Show) #}+++-- | For functions which take scalar value arguments, determines whether those+-- values are passed by reference on the host or device.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublaspointermode_t>+--+{# enum cublasPointerMode_t as PointerMode+  { underscoreToCase }+  with prefix="CUBLAS_POINTER_MODE" deriving (Eq, Show) #}+++-- | Determines whether cuBLAS routines can alternate implementations which make+-- use of atomic instructions.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasatomicsmode_t>+--+{# enum cublasAtomicsMode_t as AtomicsMode+  { underscoreToCase }+  with prefix="CUBLAS_ATOMICS" deriving (Eq, Show) #}+++-- | Used to specify the type of data underlying a @void*@ pointer. For example,+-- it is used in the routine <http://docs.nvidia.com/cuda/cublas/index.html#cublas-gemmEx ?gemmEx>.+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cuda_datatype_t>+--+#if CUDA_VERSION < 7500+data Type+#elif CUDA_VERSION < 8000+{# enum cublasDataType_t as Type+  { underscoreToCase+  , CUBLAS_DATA_FLOAT   as R32f+  , CUBLAS_DATA_DOUBLE  as R64f+  , CUBLAS_DATA_HALF    as R16f+  , CUBLAS_DATA_INT8    as R8i+  }+  with prefix="CUBLAS_DATA" deriving (Eq, Show) #}+#else+{# enum cublasDataType_t as Type+  { underscoreToCase }+  with prefix="CUDA" deriving (Eq, Show) #}+#endif+++-- | Used to run <http://docs.nvidia.com/cuda/cublas/index.html#cublas-GemmEx gemmEx>+-- with a specific, yet completely unspecified, algorithm.+--+#if CUDA_VERSION < 8000+data GemmAlgorithm+#else+{# enum cublasGemmAlgo_t as GemmAlgorithm+  { underscoreToCase+  , CUBLAS_GEMM_DFALT as GemmDefault+  }+  with prefix="CUBLAS" deriving (Eq, Show) #}+#endif+
+ Foreign/CUDA/BLAS/Level1.chs view
@@ -0,0 +1,264 @@+--+-- This module is auto-generated. Do not edit directly.+--++{-# LANGUAGE CPP #-}+{-# LANGUAGE ForeignFunctionInterface #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-unused-binds #-}+-- |+-- Module      : Foreign.CUDA.BLAS.Level1+-- Copyright   : [2017] Trevor L. McDonell+-- License     : BSD3+--+-- Maintainer  : Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>+-- Stability   : experimental+-- Portability : non-portable (GHC extensions)+--+-- For more information see the cuBLAS Level-1 function reference:+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublas-level-1-function-reference>+--++module Foreign.CUDA.BLAS.Level1 (++  isamax,+  idamax,+  icamax,+  izamax,+  isamin,+  idamin,+  icamin,+  izamin,+  sasum,+  dasum,+  scasum,+  dzasum,+  saxpy,+  daxpy,+  caxpy,+  zaxpy,+  scopy,+  dcopy,+  ccopy,+  zcopy,+  sdot,+  ddot,+  cdotu,+  zdotu,+  cdotc,+  zdotc,+  snrm2,+  dnrm2,+  scnrm2,+  dznrm2,+  srot,+  drot,+  crot,+  csrot,+  zrot,+  zdrot,+  srotg,+  drotg,+  crotg,+  zrotg,+  srotm,+  drotm,+  srotmg,+  drotmg,+  sscal,+  dscal,+  cscal,+  csscal,+  zscal,+  zdscal,+  sswap,+  dswap,+  cswap,+  zswap,++) where++import Data.Complex+import Numeric.Half+import Foreign+import Foreign.C+import Foreign.Storable.Complex ()+import Foreign.CUDA.Ptr+import Foreign.CUDA.BLAS.Error+import Foreign.CUDA.BLAS.Internal.C2HS+import Foreign.CUDA.BLAS.Internal.Types++#include "cbits/stubs.h"+{# context lib="cublas" #}++{-# INLINE useDevP #-}+useDevP :: DevicePtr a -> Ptr b+useDevP = useDevicePtr . castDevPtr++{-# INLINE useHostP #-}+useHostP :: HostPtr a -> Ptr b+useHostP = useHostPtr . castHostPtr+++{-# INLINEABLE isamax #-}+{# fun unsafe cublasIsamax_v2 as isamax { useHandle `Handle', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Int32' } -> `()' checkStatus* #}++{-# INLINEABLE idamax #-}+{# fun unsafe cublasIdamax_v2 as idamax { useHandle `Handle', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Int32' } -> `()' checkStatus* #}++{-# INLINEABLE icamax #-}+{# fun unsafe cublasIcamax_v2 as icamax { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr Int32' } -> `()' checkStatus* #}++{-# INLINEABLE izamax #-}+{# fun unsafe cublasIzamax_v2 as izamax { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr Int32' } -> `()' checkStatus* #}++{-# INLINEABLE isamin #-}+{# fun unsafe cublasIsamin_v2 as isamin { useHandle `Handle', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Int32' } -> `()' checkStatus* #}++{-# INLINEABLE idamin #-}+{# fun unsafe cublasIdamin_v2 as idamin { useHandle `Handle', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Int32' } -> `()' checkStatus* #}++{-# INLINEABLE icamin #-}+{# fun unsafe cublasIcamin_v2 as icamin { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr Int32' } -> `()' checkStatus* #}++{-# INLINEABLE izamin #-}+{# fun unsafe cublasIzamin_v2 as izamin { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr Int32' } -> `()' checkStatus* #}++{-# INLINEABLE sasum #-}+{# fun unsafe cublasSasum_v2 as sasum { useHandle `Handle', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float' } -> `()' checkStatus* #}++{-# INLINEABLE dasum #-}+{# fun unsafe cublasDasum_v2 as dasum { useHandle `Handle', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double' } -> `()' checkStatus* #}++{-# INLINEABLE scasum #-}+{# fun unsafe cublasScasum_v2 as scasum { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr Float' } -> `()' checkStatus* #}++{-# INLINEABLE dzasum #-}+{# fun unsafe cublasDzasum_v2 as dzasum { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr Double' } -> `()' checkStatus* #}++{-# INLINEABLE saxpy #-}+{# fun unsafe cublasSaxpy_v2 as saxpy { useHandle `Handle', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE daxpy #-}+{# fun unsafe cublasDaxpy_v2 as daxpy { useHandle `Handle', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE caxpy #-}+{# fun unsafe cublasCaxpy_v2 as caxpy { useHandle `Handle', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zaxpy #-}+{# fun unsafe cublasZaxpy_v2 as zaxpy { useHandle `Handle', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE scopy #-}+{# fun unsafe cublasScopy_v2 as scopy { useHandle `Handle', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dcopy #-}+{# fun unsafe cublasDcopy_v2 as dcopy { useHandle `Handle', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ccopy #-}+{# fun unsafe cublasCcopy_v2 as ccopy { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zcopy #-}+{# fun unsafe cublasZcopy_v2 as zcopy { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sdot #-}+{# fun unsafe cublasSdot_v2 as sdot { useHandle `Handle', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float' } -> `()' checkStatus* #}++{-# INLINEABLE ddot #-}+{# fun unsafe cublasDdot_v2 as ddot { useHandle `Handle', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double' } -> `()' checkStatus* #}++{-# INLINEABLE cdotu #-}+{# fun unsafe cublasCdotu_v2 as cdotu { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)' } -> `()' checkStatus* #}++{-# INLINEABLE zdotu #-}+{# fun unsafe cublasZdotu_v2 as zdotu { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)' } -> `()' checkStatus* #}++{-# INLINEABLE cdotc #-}+{# fun unsafe cublasCdotc_v2 as cdotc { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)' } -> `()' checkStatus* #}++{-# INLINEABLE zdotc #-}+{# fun unsafe cublasZdotc_v2 as zdotc { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)' } -> `()' checkStatus* #}++{-# INLINEABLE snrm2 #-}+{# fun unsafe cublasSnrm2_v2 as snrm2 { useHandle `Handle', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float' } -> `()' checkStatus* #}++{-# INLINEABLE dnrm2 #-}+{# fun unsafe cublasDnrm2_v2 as dnrm2 { useHandle `Handle', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double' } -> `()' checkStatus* #}++{-# INLINEABLE scnrm2 #-}+{# fun unsafe cublasScnrm2_v2 as scnrm2 { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr Float' } -> `()' checkStatus* #}++{-# INLINEABLE dznrm2 #-}+{# fun unsafe cublasDznrm2_v2 as dznrm2 { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr Double' } -> `()' checkStatus* #}++{-# INLINEABLE srot #-}+{# fun unsafe cublasSrot_v2 as srot { useHandle `Handle', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', castPtr `Ptr Float' } -> `()' checkStatus* #}++{-# INLINEABLE drot #-}+{# fun unsafe cublasDrot_v2 as drot { useHandle `Handle', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', castPtr `Ptr Double' } -> `()' checkStatus* #}++{-# INLINEABLE crot #-}+{# fun unsafe cublasCrot_v2 as crot { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', castPtr `Ptr (Complex Float)' } -> `()' checkStatus* #}++{-# INLINEABLE csrot #-}+{# fun unsafe cublasCsrot_v2 as csrot { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr Float', castPtr `Ptr Float' } -> `()' checkStatus* #}++{-# INLINEABLE zrot #-}+{# fun unsafe cublasZrot_v2 as zrot { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', castPtr `Ptr (Complex Double)' } -> `()' checkStatus* #}++{-# INLINEABLE zdrot #-}+{# fun unsafe cublasZdrot_v2 as zdrot { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr Double', castPtr `Ptr Double' } -> `()' checkStatus* #}++{-# INLINEABLE srotg #-}+{# fun unsafe cublasSrotg_v2 as srotg { useHandle `Handle', castPtr `Ptr Float', castPtr `Ptr Float', castPtr `Ptr Float', castPtr `Ptr Float' } -> `()' checkStatus* #}++{-# INLINEABLE drotg #-}+{# fun unsafe cublasDrotg_v2 as drotg { useHandle `Handle', castPtr `Ptr Double', castPtr `Ptr Double', castPtr `Ptr Double', castPtr `Ptr Double' } -> `()' checkStatus* #}++{-# INLINEABLE crotg #-}+{# fun unsafe cublasCrotg_v2 as crotg { useHandle `Handle', castPtr `Ptr (Complex Float)', castPtr `Ptr (Complex Float)', castPtr `Ptr (Complex Float)', castPtr `Ptr (Complex Float)' } -> `()' checkStatus* #}++{-# INLINEABLE zrotg #-}+{# fun unsafe cublasZrotg_v2 as zrotg { useHandle `Handle', castPtr `Ptr (Complex Double)', castPtr `Ptr (Complex Double)', castPtr `Ptr (Complex Double)', castPtr `Ptr (Complex Double)' } -> `()' checkStatus* #}++{-# INLINEABLE srotm #-}+{# fun unsafe cublasSrotm_v2 as srotm { useHandle `Handle', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float' } -> `()' checkStatus* #}++{-# INLINEABLE drotm #-}+{# fun unsafe cublasDrotm_v2 as drotm { useHandle `Handle', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double' } -> `()' checkStatus* #}++{-# INLINEABLE srotmg #-}+{# fun unsafe cublasSrotmg_v2 as srotmg { useHandle `Handle', castPtr `Ptr Float', castPtr `Ptr Float', castPtr `Ptr Float', castPtr `Ptr Float', castPtr `Ptr Float' } -> `()' checkStatus* #}++{-# INLINEABLE drotmg #-}+{# fun unsafe cublasDrotmg_v2 as drotmg { useHandle `Handle', castPtr `Ptr Double', castPtr `Ptr Double', castPtr `Ptr Double', castPtr `Ptr Double', castPtr `Ptr Double' } -> `()' checkStatus* #}++{-# INLINEABLE sscal #-}+{# fun unsafe cublasSscal_v2 as sscal { useHandle `Handle', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dscal #-}+{# fun unsafe cublasDscal_v2 as dscal { useHandle `Handle', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cscal #-}+{# fun unsafe cublasCscal_v2 as cscal { useHandle `Handle', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE csscal #-}+{# fun unsafe cublasCsscal_v2 as csscal { useHandle `Handle', `Int', castPtr `Ptr Float', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zscal #-}+{# fun unsafe cublasZscal_v2 as zscal { useHandle `Handle', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zdscal #-}+{# fun unsafe cublasZdscal_v2 as zdscal { useHandle `Handle', `Int', castPtr `Ptr Double', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sswap #-}+{# fun unsafe cublasSswap_v2 as sswap { useHandle `Handle', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dswap #-}+{# fun unsafe cublasDswap_v2 as dswap { useHandle `Handle', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cswap #-}+{# fun unsafe cublasCswap_v2 as cswap { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zswap #-}+{# fun unsafe cublasZswap_v2 as zswap { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}
+ Foreign/CUDA/BLAS/Level2.chs view
@@ -0,0 +1,339 @@+--+-- This module is auto-generated. Do not edit directly.+--++{-# LANGUAGE CPP #-}+{-# LANGUAGE ForeignFunctionInterface #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-unused-binds #-}+-- |+-- Module      : Foreign.CUDA.BLAS.Level2+-- Copyright   : [2017] Trevor L. McDonell+-- License     : BSD3+--+-- Maintainer  : Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>+-- Stability   : experimental+-- Portability : non-portable (GHC extensions)+--+-- For more information see the cuBLAS Level-2 function reference:+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublas-level-2-function-reference>+--++module Foreign.CUDA.BLAS.Level2 (++  Operation(..),+  Fill(..),+  Diagonal(..),+  sgbmv,+  dgbmv,+  cgbmv,+  zgbmv,+  sgemv,+  dgemv,+  cgemv,+  zgemv,+  sger,+  dger,+  cgerc,+  zgerc,+  cgeru,+  zgeru,+  ssbmv,+  dsbmv,+  sspmv,+  dspmv,+  sspr,+  dspr,+  sspr2,+  dspr2,+  ssymv,+  dsymv,+  csymv,+  zsymv,+  ssyr,+  dsyr,+  csyr,+  zsyr,+  ssyr2,+  dsyr2,+  csyr2,+  zsyr2,+  stbmv,+  dtbmv,+  ctbmv,+  ztbmv,+  stbsv,+  dtbsv,+  ctbsv,+  ztbsv,+  stpmv,+  dtpmv,+  ctpmv,+  ztpmv,+  stpsv,+  dtpsv,+  ctpsv,+  ztpsv,+  strmv,+  dtrmv,+  ctrmv,+  ztrmv,+  strsv,+  dtrsv,+  ctrsv,+  ztrsv,+  chemv,+  zhemv,+  chbmv,+  zhbmv,+  chpmv,+  zhpmv,+  cher,+  zher,+  cher2,+  zher2,+  chpr,+  zhpr,+  chpr2,+  zhpr2,++) where++import Data.Complex+import Numeric.Half+import Foreign+import Foreign.C+import Foreign.Storable.Complex ()+import Foreign.CUDA.Ptr+import Foreign.CUDA.BLAS.Error+import Foreign.CUDA.BLAS.Internal.C2HS+import Foreign.CUDA.BLAS.Internal.Types++#include "cbits/stubs.h"+{# context lib="cublas" #}++{-# INLINE useDevP #-}+useDevP :: DevicePtr a -> Ptr b+useDevP = useDevicePtr . castDevPtr++{-# INLINE useHostP #-}+useHostP :: HostPtr a -> Ptr b+useHostP = useHostPtr . castHostPtr+++{-# INLINEABLE sgbmv #-}+{# fun unsafe cublasSgbmv_v2 as sgbmv { useHandle `Handle', cFromEnum `Operation', `Int', `Int', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dgbmv #-}+{# fun unsafe cublasDgbmv_v2 as dgbmv { useHandle `Handle', cFromEnum `Operation', `Int', `Int', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgbmv #-}+{# fun unsafe cublasCgbmv_v2 as cgbmv { useHandle `Handle', cFromEnum `Operation', `Int', `Int', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgbmv #-}+{# fun unsafe cublasZgbmv_v2 as zgbmv { useHandle `Handle', cFromEnum `Operation', `Int', `Int', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sgemv #-}+{# fun unsafe cublasSgemv_v2 as sgemv { useHandle `Handle', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dgemv #-}+{# fun unsafe cublasDgemv_v2 as dgemv { useHandle `Handle', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgemv #-}+{# fun unsafe cublasCgemv_v2 as cgemv { useHandle `Handle', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgemv #-}+{# fun unsafe cublasZgemv_v2 as zgemv { useHandle `Handle', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sger #-}+{# fun unsafe cublasSger_v2 as sger { useHandle `Handle', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dger #-}+{# fun unsafe cublasDger_v2 as dger { useHandle `Handle', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgerc #-}+{# fun unsafe cublasCgerc_v2 as cgerc { useHandle `Handle', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgerc #-}+{# fun unsafe cublasZgerc_v2 as zgerc { useHandle `Handle', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgeru #-}+{# fun unsafe cublasCgeru_v2 as cgeru { useHandle `Handle', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgeru #-}+{# fun unsafe cublasZgeru_v2 as zgeru { useHandle `Handle', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ssbmv #-}+{# fun unsafe cublasSsbmv_v2 as ssbmv { useHandle `Handle', cFromEnum `Fill', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dsbmv #-}+{# fun unsafe cublasDsbmv_v2 as dsbmv { useHandle `Handle', cFromEnum `Fill', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sspmv #-}+{# fun unsafe cublasSspmv_v2 as sspmv { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dspmv #-}+{# fun unsafe cublasDspmv_v2 as dspmv { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sspr #-}+{# fun unsafe cublasSspr_v2 as sspr { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float' } -> `()' checkStatus* #}++{-# INLINEABLE dspr #-}+{# fun unsafe cublasDspr_v2 as dspr { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double' } -> `()' checkStatus* #}++{-# INLINEABLE sspr2 #-}+{# fun unsafe cublasSspr2_v2 as sspr2 { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float' } -> `()' checkStatus* #}++{-# INLINEABLE dspr2 #-}+{# fun unsafe cublasDspr2_v2 as dspr2 { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double' } -> `()' checkStatus* #}++{-# INLINEABLE ssymv #-}+{# fun unsafe cublasSsymv_v2 as ssymv { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dsymv #-}+{# fun unsafe cublasDsymv_v2 as dsymv { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE csymv #-}+{# fun unsafe cublasCsymv_v2 as csymv { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zsymv #-}+{# fun unsafe cublasZsymv_v2 as zsymv { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ssyr #-}+{# fun unsafe cublasSsyr_v2 as ssyr { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dsyr #-}+{# fun unsafe cublasDsyr_v2 as dsyr { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE csyr #-}+{# fun unsafe cublasCsyr_v2 as csyr { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zsyr #-}+{# fun unsafe cublasZsyr_v2 as zsyr { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ssyr2 #-}+{# fun unsafe cublasSsyr2_v2 as ssyr2 { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dsyr2 #-}+{# fun unsafe cublasDsyr2_v2 as dsyr2 { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE csyr2 #-}+{# fun unsafe cublasCsyr2_v2 as csyr2 { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zsyr2 #-}+{# fun unsafe cublasZsyr2_v2 as zsyr2 { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE stbmv #-}+{# fun unsafe cublasStbmv_v2 as stbmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dtbmv #-}+{# fun unsafe cublasDtbmv_v2 as dtbmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ctbmv #-}+{# fun unsafe cublasCtbmv_v2 as ctbmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ztbmv #-}+{# fun unsafe cublasZtbmv_v2 as ztbmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE stbsv #-}+{# fun unsafe cublasStbsv_v2 as stbsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dtbsv #-}+{# fun unsafe cublasDtbsv_v2 as dtbsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ctbsv #-}+{# fun unsafe cublasCtbsv_v2 as ctbsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ztbsv #-}+{# fun unsafe cublasZtbsv_v2 as ztbsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE stpmv #-}+{# fun unsafe cublasStpmv_v2 as stpmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dtpmv #-}+{# fun unsafe cublasDtpmv_v2 as dtpmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ctpmv #-}+{# fun unsafe cublasCtpmv_v2 as ctpmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ztpmv #-}+{# fun unsafe cublasZtpmv_v2 as ztpmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE stpsv #-}+{# fun unsafe cublasStpsv_v2 as stpsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dtpsv #-}+{# fun unsafe cublasDtpsv_v2 as dtpsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ctpsv #-}+{# fun unsafe cublasCtpsv_v2 as ctpsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ztpsv #-}+{# fun unsafe cublasZtpsv_v2 as ztpsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE strmv #-}+{# fun unsafe cublasStrmv_v2 as strmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dtrmv #-}+{# fun unsafe cublasDtrmv_v2 as dtrmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ctrmv #-}+{# fun unsafe cublasCtrmv_v2 as ctrmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ztrmv #-}+{# fun unsafe cublasZtrmv_v2 as ztrmv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE strsv #-}+{# fun unsafe cublasStrsv_v2 as strsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dtrsv #-}+{# fun unsafe cublasDtrsv_v2 as dtrsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ctrsv #-}+{# fun unsafe cublasCtrsv_v2 as ctrsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ztrsv #-}+{# fun unsafe cublasZtrsv_v2 as ztrsv { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE chemv #-}+{# fun unsafe cublasChemv_v2 as chemv { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zhemv #-}+{# fun unsafe cublasZhemv_v2 as zhemv { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE chbmv #-}+{# fun unsafe cublasChbmv_v2 as chbmv { useHandle `Handle', cFromEnum `Fill', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zhbmv #-}+{# fun unsafe cublasZhbmv_v2 as zhbmv { useHandle `Handle', cFromEnum `Fill', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE chpmv #-}+{# fun unsafe cublasChpmv_v2 as chpmv { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zhpmv #-}+{# fun unsafe cublasZhpmv_v2 as zhpmv { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cher #-}+{# fun unsafe cublasCher_v2 as cher { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Float', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zher #-}+{# fun unsafe cublasZher_v2 as zher { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Double', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cher2 #-}+{# fun unsafe cublasCher2_v2 as cher2 { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zher2 #-}+{# fun unsafe cublasZher2_v2 as zher2 { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE chpr #-}+{# fun unsafe cublasChpr_v2 as chpr { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Float', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)' } -> `()' checkStatus* #}++{-# INLINEABLE zhpr #-}+{# fun unsafe cublasZhpr_v2 as zhpr { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr Double', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)' } -> `()' checkStatus* #}++{-# INLINEABLE chpr2 #-}+{# fun unsafe cublasChpr2_v2 as chpr2 { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)' } -> `()' checkStatus* #}++{-# INLINEABLE zhpr2 #-}+{# fun unsafe cublasZhpr2_v2 as zhpr2 { useHandle `Handle', cFromEnum `Fill', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)' } -> `()' checkStatus* #}
+ Foreign/CUDA/BLAS/Level3.chs view
@@ -0,0 +1,558 @@+--+-- This module is auto-generated. Do not edit directly.+--++{-# LANGUAGE CPP #-}+{-# LANGUAGE ForeignFunctionInterface #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-unused-binds #-}+-- |+-- Module      : Foreign.CUDA.BLAS.Level3+-- Copyright   : [2017] Trevor L. McDonell+-- License     : BSD3+--+-- Maintainer  : Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>+-- Stability   : experimental+-- Portability : non-portable (GHC extensions)+--+-- For more information see the cuBLAS Level-3 function reference:+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublas-level-3-function-reference>+--++module Foreign.CUDA.BLAS.Level3 (++  Operation(..),+  Fill(..),+  Diagonal(..),+  Side(..),+  Type(..),+  GemmAlgorithm(..),+  sgemm,+  dgemm,+  cgemm,+  zgemm,+  sgemmBatched,+  dgemmBatched,+  cgemmBatched,+  zgemmBatched,+  ssymm,+  dsymm,+  csymm,+  zsymm,+  ssyrk,+  dsyrk,+  csyrk,+  zsyrk,+  ssyr2k,+  dsyr2k,+  csyr2k,+  zsyr2k,+  ssyrkx,+  dsyrkx,+  csyrkx,+  zsyrkx,+  strmm,+  dtrmm,+  ctrmm,+  ztrmm,+  strsm,+  dtrsm,+  ctrsm,+  ztrsm,+  strsmBatched,+  dtrsmBatched,+  ctrsmBatched,+  ztrsmBatched,+  chemm,+  zhemm,+  cherk,+  zherk,+  cher2k,+  zher2k,+  cherkx,+  zherkx,+  sgeam,+  dgeam,+  cgeam,+  zgeam,+  sdgmm,+  ddgmm,+  cdgmm,+  zdgmm,+  sgetrfBatched,+  dgetrfBatched,+  cgetrfBatched,+  zgetrfBatched,+  sgetriBatched,+  dgetriBatched,+  cgetriBatched,+  zgetriBatched,+  smatinvBatched,+  dmatinvBatched,+  cmatinvBatched,+  zmatinvBatched,+  sgeqrfBatched,+  dgeqrfBatched,+  cgeqrfBatched,+  zgeqrfBatched,+  sgelsBatched,+  dgelsBatched,+  cgelsBatched,+  zgelsBatched,+  stpttr,+  dtpttr,+  ctpttr,+  ztpttr,+  strttp,+  dtrttp,+  ctrttp,+  ztrttp,+  sgetrsBatched,+  dgetrsBatched,+  cgetrsBatched,+  zgetrsBatched,+  hgemm,+  sgemmEx,+  cgemm3m,+  zgemm3m,+  sgemmStridedBatched,+  dgemmStridedBatched,+  cgemmStridedBatched,+  zgemmStridedBatched,+  hgemmStridedBatched,+  cgemm3mStridedBatched,+  cgemmEx,+  gemmEx,+  csyrkEx,+  csyrk3mEx,+  cherkEx,+  cherk3mEx,+  nrm2Ex,+  axpyEx,+  dotEx,+  dotcEx,+  scalEx,++) where++import Data.Complex+import Numeric.Half+import Foreign+import Foreign.C+import Foreign.Storable.Complex ()+import Foreign.CUDA.Ptr+import Foreign.CUDA.BLAS.Error+import Foreign.CUDA.BLAS.Internal.C2HS+import Foreign.CUDA.BLAS.Internal.Types++#include "cbits/stubs.h"+{# context lib="cublas" #}++{-# INLINE useDevP #-}+useDevP :: DevicePtr a -> Ptr b+useDevP = useDevicePtr . castDevPtr++{-# INLINE useHostP #-}+useHostP :: HostPtr a -> Ptr b+useHostP = useHostPtr . castHostPtr+++{-# INLINEABLE sgemm #-}+{# fun unsafe cublasSgemm_v2 as sgemm { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dgemm #-}+{# fun unsafe cublasDgemm_v2 as dgemm { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgemm #-}+{# fun unsafe cublasCgemm_v2 as cgemm { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgemm #-}+{# fun unsafe cublasZgemm_v2 as zgemm { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sgemmBatched #-}+{# fun unsafe cublasSgemmBatched as sgemmBatched { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr (DevicePtr Float)', `Int', useDevP `DevicePtr (DevicePtr Float)', `Int', castPtr `Ptr Float', useDevP `DevicePtr (DevicePtr Float)', `Int', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dgemmBatched #-}+{# fun unsafe cublasDgemmBatched as dgemmBatched { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr (DevicePtr Double)', `Int', useDevP `DevicePtr (DevicePtr Double)', `Int', castPtr `Ptr Double', useDevP `DevicePtr (DevicePtr Double)', `Int', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgemmBatched #-}+{# fun unsafe cublasCgemmBatched as cgemmBatched { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgemmBatched #-}+{# fun unsafe cublasZgemmBatched as zgemmBatched { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ssymm #-}+{# fun unsafe cublasSsymm_v2 as ssymm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dsymm #-}+{# fun unsafe cublasDsymm_v2 as dsymm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE csymm #-}+{# fun unsafe cublasCsymm_v2 as csymm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zsymm #-}+{# fun unsafe cublasZsymm_v2 as zsymm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ssyrk #-}+{# fun unsafe cublasSsyrk_v2 as ssyrk { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dsyrk #-}+{# fun unsafe cublasDsyrk_v2 as dsyrk { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE csyrk #-}+{# fun unsafe cublasCsyrk_v2 as csyrk { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zsyrk #-}+{# fun unsafe cublasZsyrk_v2 as zsyrk { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ssyr2k #-}+{# fun unsafe cublasSsyr2k_v2 as ssyr2k { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dsyr2k #-}+{# fun unsafe cublasDsyr2k_v2 as dsyr2k { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE csyr2k #-}+{# fun unsafe cublasCsyr2k_v2 as csyr2k { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zsyr2k #-}+{# fun unsafe cublasZsyr2k_v2 as zsyr2k { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ssyrkx #-}+{# fun unsafe cublasSsyrkx as ssyrkx { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dsyrkx #-}+{# fun unsafe cublasDsyrkx as dsyrkx { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE csyrkx #-}+{# fun unsafe cublasCsyrkx as csyrkx { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zsyrkx #-}+{# fun unsafe cublasZsyrkx as zsyrkx { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE strmm #-}+{# fun unsafe cublasStrmm_v2 as strmm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dtrmm #-}+{# fun unsafe cublasDtrmm_v2 as dtrmm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ctrmm #-}+{# fun unsafe cublasCtrmm_v2 as ctrmm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ztrmm #-}+{# fun unsafe cublasZtrmm_v2 as ztrmm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE strsm #-}+{# fun unsafe cublasStrsm_v2 as strsm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dtrsm #-}+{# fun unsafe cublasDtrsm_v2 as dtrsm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ctrsm #-}+{# fun unsafe cublasCtrsm_v2 as ctrsm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ztrsm #-}+{# fun unsafe cublasZtrsm_v2 as ztrsm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE strsmBatched #-}+{# fun unsafe cublasStrsmBatched as strsmBatched { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr (DevicePtr Float)', `Int', useDevP `DevicePtr (DevicePtr Float)', `Int', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dtrsmBatched #-}+{# fun unsafe cublasDtrsmBatched as dtrsmBatched { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr (DevicePtr Double)', `Int', useDevP `DevicePtr (DevicePtr Double)', `Int', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ctrsmBatched #-}+{# fun unsafe cublasCtrsmBatched as ctrsmBatched { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ztrsmBatched #-}+{# fun unsafe cublasZtrsmBatched as ztrsmBatched { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', cFromEnum `Operation', cFromEnum `Diagonal', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE chemm #-}+{# fun unsafe cublasChemm_v2 as chemm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zhemm #-}+{# fun unsafe cublasZhemm_v2 as zhemm { useHandle `Handle', cFromEnum `Side', cFromEnum `Fill', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cherk #-}+{# fun unsafe cublasCherk_v2 as cherk { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr Float', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zherk #-}+{# fun unsafe cublasZherk_v2 as zherk { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr Double', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cher2k #-}+{# fun unsafe cublasCher2k_v2 as cher2k { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr Float', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zher2k #-}+{# fun unsafe cublasZher2k_v2 as zher2k { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr Double', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cherkx #-}+{# fun unsafe cublasCherkx as cherkx { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zherkx #-}+{# fun unsafe cublasZherkx as zherkx { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sgeam #-}+{# fun unsafe cublasSgeam as sgeam { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dgeam #-}+{# fun unsafe cublasDgeam as dgeam { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgeam #-}+{# fun unsafe cublasCgeam as cgeam { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgeam #-}+{# fun unsafe cublasZgeam as zgeam { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sdgmm #-}+{# fun unsafe cublasSdgmm as sdgmm { useHandle `Handle', cFromEnum `Side', `Int', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ddgmm #-}+{# fun unsafe cublasDdgmm as ddgmm { useHandle `Handle', cFromEnum `Side', `Int', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cdgmm #-}+{# fun unsafe cublasCdgmm as cdgmm { useHandle `Handle', cFromEnum `Side', `Int', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zdgmm #-}+{# fun unsafe cublasZdgmm as zdgmm { useHandle `Handle', cFromEnum `Side', `Int', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sgetrfBatched #-}+{# fun unsafe cublasSgetrfBatched as sgetrfBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr Float)', `Int', castPtr `Ptr Int32', castPtr `Ptr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dgetrfBatched #-}+{# fun unsafe cublasDgetrfBatched as dgetrfBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr Double)', `Int', castPtr `Ptr Int32', castPtr `Ptr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgetrfBatched #-}+{# fun unsafe cublasCgetrfBatched as cgetrfBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', castPtr `Ptr Int32', castPtr `Ptr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgetrfBatched #-}+{# fun unsafe cublasZgetrfBatched as zgetrfBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', castPtr `Ptr Int32', castPtr `Ptr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sgetriBatched #-}+{# fun unsafe cublasSgetriBatched as sgetriBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr Float)', `Int', useDevP `DevicePtr Int32', useDevP `DevicePtr (DevicePtr Float)', `Int', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dgetriBatched #-}+{# fun unsafe cublasDgetriBatched as dgetriBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr Double)', `Int', useDevP `DevicePtr Int32', useDevP `DevicePtr (DevicePtr Double)', `Int', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgetriBatched #-}+{# fun unsafe cublasCgetriBatched as cgetriBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', useDevP `DevicePtr Int32', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgetriBatched #-}+{# fun unsafe cublasZgetriBatched as zgetriBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', useDevP `DevicePtr Int32', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE smatinvBatched #-}+{# fun unsafe cublasSmatinvBatched as smatinvBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr Float)', `Int', useDevP `DevicePtr (DevicePtr Float)', `Int', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dmatinvBatched #-}+{# fun unsafe cublasDmatinvBatched as dmatinvBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr Double)', `Int', useDevP `DevicePtr (DevicePtr Double)', `Int', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cmatinvBatched #-}+{# fun unsafe cublasCmatinvBatched as cmatinvBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zmatinvBatched #-}+{# fun unsafe cublasZmatinvBatched as zmatinvBatched { useHandle `Handle', `Int', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sgeqrfBatched #-}+{# fun unsafe cublasSgeqrfBatched as sgeqrfBatched { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (DevicePtr Float)', `Int', useDevP `DevicePtr (DevicePtr Float)', useHostP `HostPtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dgeqrfBatched #-}+{# fun unsafe cublasDgeqrfBatched as dgeqrfBatched { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (DevicePtr Double)', `Int', useDevP `DevicePtr (DevicePtr Double)', useHostP `HostPtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgeqrfBatched #-}+{# fun unsafe cublasCgeqrfBatched as cgeqrfBatched { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', useDevP `DevicePtr (DevicePtr (Complex Float))', useHostP `HostPtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgeqrfBatched #-}+{# fun unsafe cublasZgeqrfBatched as zgeqrfBatched { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', useDevP `DevicePtr (DevicePtr (Complex Double))', useHostP `HostPtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sgelsBatched #-}+{# fun unsafe cublasSgelsBatched as sgelsBatched { useHandle `Handle', cFromEnum `Operation', `Int', `Int', `Int', useDevP `DevicePtr (DevicePtr Float)', `Int', useDevP `DevicePtr (DevicePtr Float)', `Int', useHostP `HostPtr Int32', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dgelsBatched #-}+{# fun unsafe cublasDgelsBatched as dgelsBatched { useHandle `Handle', cFromEnum `Operation', `Int', `Int', `Int', useDevP `DevicePtr (DevicePtr Double)', `Int', useDevP `DevicePtr (DevicePtr Double)', `Int', useHostP `HostPtr Int32', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgelsBatched #-}+{# fun unsafe cublasCgelsBatched as cgelsBatched { useHandle `Handle', cFromEnum `Operation', `Int', `Int', `Int', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', useHostP `HostPtr Int32', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgelsBatched #-}+{# fun unsafe cublasZgelsBatched as zgelsBatched { useHandle `Handle', cFromEnum `Operation', `Int', `Int', `Int', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', useHostP `HostPtr Int32', useDevP `DevicePtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE stpttr #-}+{# fun unsafe cublasStpttr as stpttr { useHandle `Handle', cFromEnum `Fill', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dtpttr #-}+{# fun unsafe cublasDtpttr as dtpttr { useHandle `Handle', cFromEnum `Fill', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ctpttr #-}+{# fun unsafe cublasCtpttr as ctpttr { useHandle `Handle', cFromEnum `Fill', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE ztpttr #-}+{# fun unsafe cublasZtpttr as ztpttr { useHandle `Handle', cFromEnum `Fill', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE strttp #-}+{# fun unsafe cublasStrttp as strttp { useHandle `Handle', cFromEnum `Fill', `Int', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float' } -> `()' checkStatus* #}++{-# INLINEABLE dtrttp #-}+{# fun unsafe cublasDtrttp as dtrttp { useHandle `Handle', cFromEnum `Fill', `Int', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double' } -> `()' checkStatus* #}++{-# INLINEABLE ctrttp #-}+{# fun unsafe cublasCtrttp as ctrttp { useHandle `Handle', cFromEnum `Fill', `Int', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)' } -> `()' checkStatus* #}++{-# INLINEABLE ztrttp #-}+{# fun unsafe cublasZtrttp as ztrttp { useHandle `Handle', cFromEnum `Fill', `Int', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)' } -> `()' checkStatus* #}+#if CUDA_VERSION >= 7000++{-# INLINEABLE sgetrsBatched #-}+{# fun unsafe cublasSgetrsBatched as sgetrsBatched { useHandle `Handle', cFromEnum `Operation', `Int', `Int', useDevP `DevicePtr (DevicePtr Float)', `Int', useDevP `DevicePtr Int32', useDevP `DevicePtr (DevicePtr Float)', `Int', useHostP `HostPtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dgetrsBatched #-}+{# fun unsafe cublasDgetrsBatched as dgetrsBatched { useHandle `Handle', cFromEnum `Operation', `Int', `Int', useDevP `DevicePtr (DevicePtr Double)', `Int', useDevP `DevicePtr Int32', useDevP `DevicePtr (DevicePtr Double)', `Int', useHostP `HostPtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgetrsBatched #-}+{# fun unsafe cublasCgetrsBatched as cgetrsBatched { useHandle `Handle', cFromEnum `Operation', `Int', `Int', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', useDevP `DevicePtr Int32', useDevP `DevicePtr (DevicePtr (Complex Float))', `Int', useHostP `HostPtr Int32', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgetrsBatched #-}+{# fun unsafe cublasZgetrsBatched as zgetrsBatched { useHandle `Handle', cFromEnum `Operation', `Int', `Int', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', useDevP `DevicePtr Int32', useDevP `DevicePtr (DevicePtr (Complex Double))', `Int', useHostP `HostPtr Int32', `Int' } -> `()' checkStatus* #}+#else++sgetrsBatched :: Handle -> Operation -> Int -> Int -> DevicePtr (DevicePtr Float) -> Int -> DevicePtr Int32 -> DevicePtr (DevicePtr Float) -> Int -> HostPtr Int32 -> Int -> IO ()+sgetrsBatched _ _ _ _ _ _ _ _ _ _ _ = cublasError "'sgetrsBatched' requires at least cuda-7.0"++dgetrsBatched :: Handle -> Operation -> Int -> Int -> DevicePtr (DevicePtr Double) -> Int -> DevicePtr Int32 -> DevicePtr (DevicePtr Double) -> Int -> HostPtr Int32 -> Int -> IO ()+dgetrsBatched _ _ _ _ _ _ _ _ _ _ _ = cublasError "'dgetrsBatched' requires at least cuda-7.0"++cgetrsBatched :: Handle -> Operation -> Int -> Int -> DevicePtr (DevicePtr (Complex Float)) -> Int -> DevicePtr Int32 -> DevicePtr (DevicePtr (Complex Float)) -> Int -> HostPtr Int32 -> Int -> IO ()+cgetrsBatched _ _ _ _ _ _ _ _ _ _ _ = cublasError "'cgetrsBatched' requires at least cuda-7.0"++zgetrsBatched :: Handle -> Operation -> Int -> Int -> DevicePtr (DevicePtr (Complex Double)) -> Int -> DevicePtr Int32 -> DevicePtr (DevicePtr (Complex Double)) -> Int -> HostPtr Int32 -> Int -> IO ()+zgetrsBatched _ _ _ _ _ _ _ _ _ _ _ = cublasError "'zgetrsBatched' requires at least cuda-7.0"+#endif+#if CUDA_VERSION >= 7500++{-# INLINEABLE hgemm #-}+{# fun unsafe cublasHgemm as hgemm { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Half', useDevP `DevicePtr Half', `Int', useDevP `DevicePtr Half', `Int', castPtr `Ptr Half', useDevP `DevicePtr Half', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sgemmEx #-}+{# fun unsafe cublasSgemmEx as sgemmEx { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr ()', cFromEnum `Type', `Int', useDevP `DevicePtr ()', cFromEnum `Type', `Int', castPtr `Ptr Float', useDevP `DevicePtr ()', cFromEnum `Type', `Int' } -> `()' checkStatus* #}+#else++hgemm :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr Half -> DevicePtr Half -> Int -> DevicePtr Half -> Int -> Ptr Half -> DevicePtr Half -> Int -> IO ()+hgemm _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'hgemm' requires at least cuda-7.5"++sgemmEx :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr Float -> DevicePtr () -> Type -> Int -> DevicePtr () -> Type -> Int -> Ptr Float -> DevicePtr () -> Type -> Int -> IO ()+sgemmEx _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'sgemmEx' requires at least cuda-7.5"+#endif+#if CUDA_VERSION >= 8000++{-# INLINEABLE cgemm3m #-}+{# fun unsafe cublasCgemm3m as cgemm3m { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgemm3m #-}+{# fun unsafe cublasZgemm3m as zgemm3m { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE sgemmStridedBatched #-}+{# fun unsafe cublasSgemmStridedBatched as sgemmStridedBatched { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', `Int64', useDevP `DevicePtr Float', `Int', `Int64', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', `Int64', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE dgemmStridedBatched #-}+{# fun unsafe cublasDgemmStridedBatched as dgemmStridedBatched { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', `Int64', useDevP `DevicePtr Double', `Int', `Int64', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', `Int64', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgemmStridedBatched #-}+{# fun unsafe cublasCgemmStridedBatched as cgemmStridedBatched { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', `Int64', useDevP `DevicePtr (Complex Float)', `Int', `Int64', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', `Int64', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE zgemmStridedBatched #-}+{# fun unsafe cublasZgemmStridedBatched as zgemmStridedBatched { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', `Int64', useDevP `DevicePtr (Complex Double)', `Int', `Int64', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', `Int64', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE hgemmStridedBatched #-}+{# fun unsafe cublasHgemmStridedBatched as hgemmStridedBatched { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Half', useDevP `DevicePtr Half', `Int', `Int64', useDevP `DevicePtr Half', `Int', `Int64', castPtr `Ptr Half', useDevP `DevicePtr Half', `Int', `Int64', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgemm3mStridedBatched #-}+{# fun unsafe cublasCgemm3mStridedBatched as cgemm3mStridedBatched { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', `Int64', useDevP `DevicePtr (Complex Float)', `Int', `Int64', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', `Int64', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cgemmEx #-}+{# fun unsafe cublasCgemmEx as cgemmEx { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr ()', cFromEnum `Type', `Int', useDevP `DevicePtr ()', cFromEnum `Type', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr ()', cFromEnum `Type', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE gemmEx #-}+{# fun unsafe cublasGemmEx as gemmEx { useHandle `Handle', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr ()', useDevP `DevicePtr ()', cFromEnum `Type', `Int', useDevP `DevicePtr ()', cFromEnum `Type', `Int', castPtr `Ptr ()', useDevP `DevicePtr ()', cFromEnum `Type', `Int', cFromEnum `Type', cFromEnum `GemmAlgorithm' } -> `()' checkStatus* #}++{-# INLINEABLE csyrkEx #-}+{# fun unsafe cublasCsyrkEx as csyrkEx { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr ()', cFromEnum `Type', `Int', castPtr `Ptr Float', useDevP `DevicePtr (Complex Float)', cFromEnum `Type', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE csyrk3mEx #-}+{# fun unsafe cublasCsyrk3mEx as csyrk3mEx { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr ()', cFromEnum `Type', `Int', castPtr `Ptr Float', useDevP `DevicePtr (Complex Float)', cFromEnum `Type', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cherkEx #-}+{# fun unsafe cublasCherkEx as cherkEx { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr ()', cFromEnum `Type', `Int', castPtr `Ptr Float', useDevP `DevicePtr (Complex Float)', cFromEnum `Type', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE cherk3mEx #-}+{# fun unsafe cublasCherk3mEx as cherk3mEx { useHandle `Handle', cFromEnum `Fill', cFromEnum `Operation', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr ()', cFromEnum `Type', `Int', castPtr `Ptr Float', useDevP `DevicePtr (Complex Float)', cFromEnum `Type', `Int' } -> `()' checkStatus* #}++{-# INLINEABLE nrm2Ex #-}+{# fun unsafe cublasNrm2Ex as nrm2Ex { useHandle `Handle', `Int', useDevP `DevicePtr ()', cFromEnum `Type', `Int', castPtr `Ptr ()', cFromEnum `Type', cFromEnum `Type' } -> `()' checkStatus* #}++{-# INLINEABLE axpyEx #-}+{# fun unsafe cublasAxpyEx as axpyEx { useHandle `Handle', `Int', castPtr `Ptr ()', cFromEnum `Type', useDevP `DevicePtr ()', cFromEnum `Type', `Int', useDevP `DevicePtr ()', cFromEnum `Type', `Int', cFromEnum `Type' } -> `()' checkStatus* #}++{-# INLINEABLE dotEx #-}+{# fun unsafe cublasDotEx as dotEx { useHandle `Handle', `Int', useDevP `DevicePtr ()', cFromEnum `Type', `Int', useDevP `DevicePtr ()', cFromEnum `Type', `Int', castPtr `Ptr ()', cFromEnum `Type', cFromEnum `Type' } -> `()' checkStatus* #}++{-# INLINEABLE dotcEx #-}+{# fun unsafe cublasDotcEx as dotcEx { useHandle `Handle', `Int', useDevP `DevicePtr ()', cFromEnum `Type', `Int', useDevP `DevicePtr ()', cFromEnum `Type', `Int', castPtr `Ptr ()', cFromEnum `Type', cFromEnum `Type' } -> `()' checkStatus* #}++{-# INLINEABLE scalEx #-}+{# fun unsafe cublasScalEx as scalEx { useHandle `Handle', `Int', castPtr `Ptr ()', cFromEnum `Type', useDevP `DevicePtr ()', cFromEnum `Type', `Int', cFromEnum `Type' } -> `()' checkStatus* #}+#else++cgemm3m :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Float) -> DevicePtr (Complex Float) -> Int -> DevicePtr (Complex Float) -> Int -> Ptr (Complex Float) -> DevicePtr (Complex Float) -> Int -> IO ()+cgemm3m _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'cgemm3m' requires at least cuda-8.0"++zgemm3m :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Double) -> DevicePtr (Complex Double) -> Int -> DevicePtr (Complex Double) -> Int -> Ptr (Complex Double) -> DevicePtr (Complex Double) -> Int -> IO ()+zgemm3m _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'zgemm3m' requires at least cuda-8.0"++sgemmStridedBatched :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr Float -> DevicePtr Float -> Int -> Int64 -> DevicePtr Float -> Int -> Int64 -> Ptr Float -> DevicePtr Float -> Int -> Int64 -> Int -> IO ()+sgemmStridedBatched _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'sgemmStridedBatched' requires at least cuda-8.0"++dgemmStridedBatched :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr Double -> DevicePtr Double -> Int -> Int64 -> DevicePtr Double -> Int -> Int64 -> Ptr Double -> DevicePtr Double -> Int -> Int64 -> Int -> IO ()+dgemmStridedBatched _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'dgemmStridedBatched' requires at least cuda-8.0"++cgemmStridedBatched :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Float) -> DevicePtr (Complex Float) -> Int -> Int64 -> DevicePtr (Complex Float) -> Int -> Int64 -> Ptr (Complex Float) -> DevicePtr (Complex Float) -> Int -> Int64 -> Int -> IO ()+cgemmStridedBatched _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'cgemmStridedBatched' requires at least cuda-8.0"++zgemmStridedBatched :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Double) -> DevicePtr (Complex Double) -> Int -> Int64 -> DevicePtr (Complex Double) -> Int -> Int64 -> Ptr (Complex Double) -> DevicePtr (Complex Double) -> Int -> Int64 -> Int -> IO ()+zgemmStridedBatched _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'zgemmStridedBatched' requires at least cuda-8.0"++hgemmStridedBatched :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr Half -> DevicePtr Half -> Int -> Int64 -> DevicePtr Half -> Int -> Int64 -> Ptr Half -> DevicePtr Half -> Int -> Int64 -> Int -> IO ()+hgemmStridedBatched _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'hgemmStridedBatched' requires at least cuda-8.0"++cgemm3mStridedBatched :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Float) -> DevicePtr (Complex Float) -> Int -> Int64 -> DevicePtr (Complex Float) -> Int -> Int64 -> Ptr (Complex Float) -> DevicePtr (Complex Float) -> Int -> Int64 -> Int -> IO ()+cgemm3mStridedBatched _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'cgemm3mStridedBatched' requires at least cuda-8.0"++cgemmEx :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Float) -> DevicePtr () -> Type -> Int -> DevicePtr () -> Type -> Int -> Ptr (Complex Float) -> DevicePtr () -> Type -> Int -> IO ()+cgemmEx _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'cgemmEx' requires at least cuda-8.0"++gemmEx :: Handle -> Operation -> Operation -> Int -> Int -> Int -> Ptr () -> DevicePtr () -> Type -> Int -> DevicePtr () -> Type -> Int -> Ptr () -> DevicePtr () -> Type -> Int -> Type -> GemmAlgorithm -> IO ()+gemmEx _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'gemmEx' requires at least cuda-8.0"++csyrkEx :: Handle -> Fill -> Operation -> Int -> Int -> Ptr Float -> DevicePtr () -> Type -> Int -> Ptr Float -> DevicePtr (Complex Float) -> Type -> Int -> IO ()+csyrkEx _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'csyrkEx' requires at least cuda-8.0"++csyrk3mEx :: Handle -> Fill -> Operation -> Int -> Int -> Ptr Float -> DevicePtr () -> Type -> Int -> Ptr Float -> DevicePtr (Complex Float) -> Type -> Int -> IO ()+csyrk3mEx _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'csyrk3mEx' requires at least cuda-8.0"++cherkEx :: Handle -> Fill -> Operation -> Int -> Int -> Ptr Float -> DevicePtr () -> Type -> Int -> Ptr Float -> DevicePtr (Complex Float) -> Type -> Int -> IO ()+cherkEx _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'cherkEx' requires at least cuda-8.0"++cherk3mEx :: Handle -> Fill -> Operation -> Int -> Int -> Ptr Float -> DevicePtr () -> Type -> Int -> Ptr Float -> DevicePtr (Complex Float) -> Type -> Int -> IO ()+cherk3mEx _ _ _ _ _ _ _ _ _ _ _ _ _ = cublasError "'cherk3mEx' requires at least cuda-8.0"++nrm2Ex :: Handle -> Int -> DevicePtr () -> Type -> Int -> Ptr () -> Type -> Type -> IO ()+nrm2Ex _ _ _ _ _ _ _ _ = cublasError "'nrm2Ex' requires at least cuda-8.0"++axpyEx :: Handle -> Int -> Ptr () -> Type -> DevicePtr () -> Type -> Int -> DevicePtr () -> Type -> Int -> Type -> IO ()+axpyEx _ _ _ _ _ _ _ _ _ _ _ = cublasError "'axpyEx' requires at least cuda-8.0"++dotEx :: Handle -> Int -> DevicePtr () -> Type -> Int -> DevicePtr () -> Type -> Int -> Ptr () -> Type -> Type -> IO ()+dotEx _ _ _ _ _ _ _ _ _ _ _ = cublasError "'dotEx' requires at least cuda-8.0"++dotcEx :: Handle -> Int -> DevicePtr () -> Type -> Int -> DevicePtr () -> Type -> Int -> Ptr () -> Type -> Type -> IO ()+dotcEx _ _ _ _ _ _ _ _ _ _ _ = cublasError "'dotcEx' requires at least cuda-8.0"++scalEx :: Handle -> Int -> Ptr () -> Type -> DevicePtr () -> Type -> Int -> Type -> IO ()+scalEx _ _ _ _ _ _ _ _ = cublasError "'scalEx' requires at least cuda-8.0"+#endif
+ Foreign/CUDA/BLAS/Stream.chs view
@@ -0,0 +1,43 @@+{-# LANGUAGE CPP                      #-}+{-# LANGUAGE ForeignFunctionInterface #-}+-- |+-- Module      : Foreign.CUDA.BLAS.Stream+-- Copyright   : [2014..2017] Trevor L. McDonell+-- License     : BSD3+--+-- Maintainer  : Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>+-- Stability   : experimental+-- Portability : non-portable (GHC extensions)+--++module Foreign.CUDA.BLAS.Stream (++  setStream,++) where++import Foreign.CUDA.Driver.Stream+import Foreign.CUDA.BLAS.Error+import Foreign.CUDA.BLAS.Internal.C2HS+import Foreign.CUDA.BLAS.Internal.Types++import Foreign.C+import Foreign.Ptr++#include "cbits/stubs.h"+{# context lib="cublas" #}+++-- | Sets the execution stream which all subsequent cuBLAS library functions+-- will execute with. If not set, functions execute in the default stream (which+-- never overlaps any other operations).+--+-- <http://docs.nvidia.com/cuda/cublas/index.html#cublassetstream>+--+{-# INLINEABLE setStream #-}+{# fun unsafe cublasSetStream_v2 as setStream+  { useHandle `Handle'+  , useStream `Stream'+  }+  -> `()' checkStatus* #}+
− Foreign/CUDA/Cublas.hs 
@@ -1,29 +0,0 @@-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE FlexibleInstances #-}--{- |-This module provides the most convenient FFI bindings to the CUBLAS-library. The names of functions and the role of arguments closely follows-the CUBLAS C API, which is documented here:--<http://docs.nvidia.com/cuda/cublas/>--}--module Foreign.CUDA.Cublas (-  -- * Types-  module Foreign.CUDA.Cublas.Types,-  -- * Initialization and destruction-  create, destroy,-  -- * BLAS functions-  module Foreign.CUDA.Cublas,-  -- * Error handling-  module Foreign.CUDA.Cublas.Error )-where--import Foreign.CUDA.Cublas.TH-import Foreign.CUDA.Cublas.FFI--import Foreign.CUDA.Cublas.Types-import Foreign.CUDA.Cublas.Error--$(doIO $ makeClassDecs "cublas" cublasFile)
− Foreign/CUDA/Cublas/Error.hs 
@@ -1,55 +0,0 @@-{-# LANGUAGE DeriveDataTypeable       #-}--module Foreign.CUDA.Cublas.Error where-import Foreign.CUDA.Cublas.Types (Status (..))---- System-import Data.Typeable-import Control.Exception----- Error codes ------------------------------------------------------------------------ Describe each error code----describe :: Status -> String-describe Success         = "success"-describe NotInitialized  = "library not initialised"-describe AllocFailed     = "resource allocation failed"-describe InvalidValue    = "unsupported value or parameter passed to a function"-describe ArchMismatch    = "unsupported on current architecture"-describe MappingError    = "access to GPU memory failed"-describe ExecutionFailed = "execution failed"-describe InternalError   = "internal error"----- Exceptions ----------------------------------------------------------------------data CUBLASException-  = ExitCode  Status-  | UserError String-  deriving Typeable--instance Exception CUBLASException--instance Show CUBLASException where-  showsPrec _ (ExitCode  s) = showString ("CUBLAS Exception: " ++ describe s)-  showsPrec _ (UserError s) = showString ("CUBLAS Exception: " ++ s)----- | Raise a CUBLASException in the IO Monad----cublasError :: String -> IO a-cublasError s = throwIO (UserError s)----- | Return the results of a function on successful execution, otherwise throw--- an exception with an error string associated with the return code----resultIfOk :: (Status, a) -> IO a-resultIfOk (status,result) =-    case status of-        Success -> return  result-        _       -> throwIO (ExitCode status)-
− Foreign/CUDA/Cublas/FFI.hs 
@@ -1,9 +0,0 @@-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE ForeignFunctionInterface #-}--module Foreign.CUDA.Cublas.FFI where-import Foreign.CUDA.Cublas.TH-import Foreign.C.Types--$(doIO $ makeFFIDecs  "cublas" cublasFile)-$(doIO $ makeAllFuncs "cublas" cublasFile)
− Foreign/CUDA/Cublas/TH.hs 
@@ -1,445 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE ForeignFunctionInterface #-}--module Foreign.CUDA.Cublas.TH where-import Control.Applicative-import Control.Arrow-import Control.Monad ((>=>), join, void)--import GHC.Exts (groupWith)--import Language.Haskell.TH as TH-import Language.C-import Language.C.System.GCC--import Data.List (isInfixOf, isPrefixOf, isSuffixOf)-import Data.Char (toLower, toUpper)-import Data.Maybe (mapMaybe)--import Debug.Trace-import qualified Foreign.C.Types as C-import qualified Foreign as F-import Foreign.Storable.Complex ()-import Data.Complex (Complex(..))--import System.FilePath.Posix ((</>))--import Foreign.CUDA as FC-import qualified Foreign.CUDA.Runtime.Stream as FC--import qualified Foreign.CUDA.Cublas.Types as BL-import qualified Foreign.CUDA.Cusparse.Types as SP-import qualified Foreign.CUDA.Cublas.Error as BL-import qualified Foreign.CUDA.Cusparse.Error as SP--try :: [(Bool, a)] -> a-try ((p,y):conds) = if p then y else try conds-try [] = error "TH.try: No match!"--data TypeInfo = TI -  { ctype    :: Q Type-  , hsinput  :: Either Convert Create-  , hsoutput :: Maybe (Either Convert Destroy) }--data TypeDat = TD -  { ct    :: Q Type-  , hst   :: Q Type -  , c2hs  :: (Q Exp, ExpType)-  , hs2c  :: (Q Exp, ExpType) }--data ExpType = Pure | Monadic--data TypeC = VoidC | IntC | FloatC | DoubleC | EnumC String -           | ComplexC TypeC | ArbStructC String | PtrC TypeC | PhonyC TH.Name-           | ArrC TypeC-           deriving (Eq, Show)--prim :: Q Type -> Q Type -> Q Exp -> Q Exp -> TypeDat-prim ct hst c2hs hs2c = TD ct hst (c2hs, Pure) (hs2c, Pure)--simple :: Q Type -> TypeDat-simple t = prim t t [| id |] [| id |]--bothc :: (a -> b) -> Complex a -> Complex b-bothc f (a :+ b) = f a :+ f b --typeDat :: TypeC -> TypeDat-typeDat (PhonyC n)  = simple (varT n)-typeDat VoidC       = simple [t| () |] -typeDat (PtrC t)    = prim [t| F.Ptr $(ctype) |] [t| FC.DevicePtr $(ctype) |] [| FC.DevicePtr |]       [| FC.useDevicePtr |] where-  ctype = ct (typeDat t)-typeDat (ArrC t)    = typeDat (PtrC t)-typeDat IntC        = prim [t| C.CInt |]    [t| Int |]    [| fromIntegral |]          [| fromIntegral |]-typeDat FloatC      = simple [t| C.CFloat |]-typeDat DoubleC     = simple [t| C.CDouble |]-typeDat (EnumC str) = prim [t| C.CInt |] x [| toEnum . fromIntegral |] [| fromIntegral . fromEnum |] where-  x = case str of-    "cublasStatus_t" -> [t| BL.Status |]-    "cublasOperation_t" -> [t| BL.Operation |]-    "cublasSideMode_t" -> [t| BL.SideMode |]-    "cublasFillMode_t" -> [t| BL.FillMode |]-    "cublasPointerMode_t" -> [t| BL.PointerMode |]-    "cublasAtomicsMode_t" -> [t| BL.AtomicsMode |]-    "cublasDiagType_t" -> [t| BL.DiagType |]--    "cusparseStatus_t" -> [t| SP.Status |]-    "cusparseOperation_t" -> [t| SP.Operation |]-    "cusparseDirection_t" -> [t| SP.Direction |]-    "cusparseHybPartition_t" -> [t| SP.HybPartition |]-    "cusparseFillMode_t" -> [t| SP.FillMode |]-    "cusparsePointerMode_t" -> [t| SP.PointerMode |]-    "cusparseDiagType_t" -> [t| SP.DiagType |]-    "cusparseIndexBase_t" -> [t| SP.IndexBase |]-    "cusparseAction_t" -> [t| SP.Action |]-    "cusparseMatrixType_t" -> [t| SP.MatrixType |]-    "cusparseSolvePolicy_t" -> [t| SP.SolvePolicy |]--    otherwise -> error ("typeDat.EnumC : Missing type: " ++ str)-typeDat (ArbStructC str) = case str of-  "cublasHandle_t" -> prim [t| F.Ptr () |] [t| BL.Handle |] [| BL.Handle |]  [| BL.useHandle |]-  "cusparseHandle_t" -> prim [t| F.Ptr () |] [t| SP.Handle |] [| SP.Handle |]  [| SP.useHandle |]-  "cusparseHybMat_t" -> prim [t| F.Ptr () |] [t| SP.HybMat |] [| SP.HybMat |]  [| SP.useHybMat |]-  "cusparseMatDescr_t" -> prim [t| F.Ptr () |] [t| SP.MatDescr |] [| SP.MatDescr |]  [| SP.useMatDescr |]-  "cusparseSolveAnalysisInfo_t" -> prim [t| F.Ptr () |] [t| SP.SolveAnalysisInfo |] [| SP.SolveAnalysisInfo |]  [| SP.useSolveAnalysisInfo |]-  "csrsv2Info_t" -> prim [t| F.Ptr () |] [t| SP.Csrsv2Info |] [| SP.Csrsv2Info |] [| SP.useCsrsv2Info |]-  "csric02Info_t" -> prim [t| F.Ptr () |] [t| SP.Csric02Info |] [| SP.Csric02Info |] [| SP.useCsric02Info |]-  "csrilu02Info_t" -> prim [t| F.Ptr () |] [t| SP.Csrilu02Info |] [| SP.Csrilu02Info |] [| SP.useCsrilu02Info |]-  "bsrsv2Info_t" -> prim [t| F.Ptr () |] [t| SP.Bsrsv2Info |] [| SP.Bsrsv2Info |] [| SP.useBsrsv2Info |]-  "bsric02Info_t" -> prim [t| F.Ptr () |] [t| SP.Bsric02Info |] [| SP.Bsric02Info |] [| SP.useBsric02Info |]-  "bsrilu02Info_t" -> prim [t| F.Ptr () |] [t| SP.Bsrilu02Info |] [| SP.Bsrilu02Info |] [| SP.useBsrilu02Info |]-  "bsrsm2Info_t" -> prim [t| F.Ptr () |] [t| SP.Bsrsm2Info |] [| SP.Bsrsm2Info |] [| SP.useBsrsm2Info |]--  "cudaStream_t" -> prim [t| F.Ptr () |] [t| FC.Stream |] [| FC.Stream |] [| FC.useStream |]-typeDat (ComplexC t) = prim-  [t| Complex $(ctype) |]-  [t| Complex $(hstype) |]-  [| bothc $(fromC) |]-  [| bothc $(toC) |]-  where-  TD ctype hstype (fromC, Pure) (toC, Pure) = typeDat t---convertT x y = Left (Convert x y)-createT = Right . Create-destroyT = Right . Destroy--data Convert = Convert (Q Type) (Q Exp)-newtype Create = Create (Q Exp)-newtype Destroy = Destroy (Q Exp)--pointerify :: Q Type -> Q Type-pointerify x = [t| F.Ptr $(x) |]--useT :: TypeC -> TypeInfo-useT = useT' . typeDat where-  useT' (TD ct hst c2hs (hs2c,purity)) = TI-    ct-    (convertT hst exp)-    Nothing-    where-    exp = case purity of Pure -> [| return . $(hs2c) |]; Monadic -> hs2c--inT :: TypeC -> TypeInfo-inT (PtrC t) = inT' (typeDat t) where-  inT' (TD ct hst c2hs (hs2c,purity)) = TI-    (pointerify ct)-    (convertT hst exp)-    (Just (destroyT [| F.free |]))-    where-    exp = case purity of Pure -> [| F.new . $(hs2c) |] ; Monadic -> undefined-inT (ArrC t) = inT' (typeDat t) where-  inT' (TD ct hst c2hs (hs2c,purity)) = TI-    (pointerify ct)-    (convertT [t| [ $(hst) ] |] exp)-    (Just (destroyT [| FC.free . FC.DevicePtr |]))-    where-    exp = case purity of Pure -> [| fmap FC.useDevicePtr . FC.newListArray . map $(hs2c) |] ; Monadic -> undefined--outT :: TypeC -> TypeInfo-outT (PtrC t) = outT' (typeDat t) where-  outT' (TD ct hst (c2hs,purity) hs2c) = TI-    ct-    (createT [| F.malloc |])-    (Just (convertT hst [| \p -> do { x <- F.peek p ; F.free p; $(exp) x } |]))-    where-    exp = case purity of Pure -> [| return . $(c2hs) |] ; Monadic -> c2hs--inOutT :: TypeC -> TypeInfo-inOutT (PtrC t) = inOutT' (typeDat t) where-  inOutT' (TD ct hst (c2hs,purity1) (hs2c,purity2)) = TI-    (pointerify ct)-    (convertT hst exp1)-    (Just (convertT hst [| \p -> do { x <- F.peek p ; F.free p; $(exp2) x } |]))-    where-    exp1 = case purity1 of Pure -> [| F.new . $(hs2c) |] ; Monadic -> hs2c-    exp2 = case purity2 of Pure -> [| return . $(c2hs) |] ; Monadic -> c2hs--convert :: CTypeSpecifier a -> TypeC-convert (CVoidType _) = VoidC---CCharType a	 ---CShortType a	 -convert (CIntType _) = IntC---CLongType a	 -convert (CFloatType _) = FloatC-convert (CDoubleType _) = DoubleC---CSignedType a	 ---CUnsigType a	 ---CBoolType a	 ---CComplexType a-convert (CTypeDef ident _) = try -  [ (s `elem` ["cublasHandle_t", "cusparseHybMat_t", "cusparseHandle_t", "cusparseMatDescr_t", "cusparseSolveAnalysisInfo_t", "cudaStream_t", "csrsv2Info_t", "csric02Info_t", "csrilu02Info_t", "bsrsv2Info_t", "bsric02Info_t", "bsrilu02Info_t", "bsrsm2Info_t" ] , ArbStructC s)-  , (s=="cuComplex", ComplexC FloatC)-  , (s=="cuDoubleComplex", ComplexC DoubleC)-  , (True, EnumC s) ]-  where-  s = identToString ident-convert _ = VoidC--convert' :: [CDeclarationSpecifier a] -> TypeC-convert' (CTypeSpec x:_) = convert x-convert' (_:xs) = convert' xs-convert' [] = error "convert': invalid CDeclarationSpecifier list"--typeOf :: (TypeC -> Q Type) -> CDeclaration a -> Q Type-typeOf proj (CDecl basetype [(Just (CDeclr (Just ident) ptrs _ _ _), _, _)] _) = -  foldr f (proj $ convert' basetype) ptrs-  where-  f (CPtrDeclr _ _) b = [t| F.Ptr $(b) |]-  f _ _ = error "haven't implemented other things"--pointerification :: CDeclaration a -> (TypeC -> TypeC)-pointerification (CDecl _ [(Just (CDeclr _ ptrs _ _ _), _, _)] _) = foldr (.) id $ map f ptrs where-  f (CPtrDeclr _ _) = PtrC-  f (CArrDeclr _ _ _) = ArrC-  f _ = id --possible there are other things that should be here?--baseType :: CDeclaration a -> TypeC-baseType (CDecl basetype _ _) = convert' basetype--cType :: CDeclaration a -> TypeC-cType d = (pointerification d) (baseType d)-  --typeInfo :: String -> CVar -> TypeInfo-typeInfo fn (n, typec) = ($ typec) $ try-  [ {- CUBLAS -}-    (case typec of ArrC _ -> True; otherwise -> False-      , inT)-  , (n `elem` ["alpha", "beta", "a", "b", "c", "d1", "d2", "x1", "y1", "s"]-      , inT)-  , ( "create" `isPrefixOf` fn || n == "result"-      , outT)-    {- CuSPARSE -}-  , ("DevHostPtr" `isSuffixOf` n-      , outT)-    {- End -}-  , (True-      , useT)-  ]--declName :: CDeclaration a -> Maybe String-declName (CDecl _ [(Just (CDeclr (Just ident) _ _ _ _), _, _)] _) = Just (identToString ident)-declName _ = Nothing--outMarshall :: TypeC -> (Q Exp, Q Type -> Q Type)-outMarshall (EnumC "cublasStatus_t") = ([| BL.resultIfOk |], id)-outMarshall (EnumC "cusparseStatus_t") = ([| SP.resultIfOk |], id)-outMarshall VoidC = ([| return . snd |], id)-outMarshall x = ([| return . fst |], const (hst $ typeDat x))----createf' :: (String, CFunction) -> Q [Dec]-createf' (foreignname, cf@(fname, rettype, args)) = do-  ins <- mapM (safeName "_in") args-  toCs <- mapM (safeName "_out") args-  (outstatements, (outtypes, outs)) <- second (unzip . filterMaybes) . unzip <$> collect (zip3 args argsTI toCs)-  let instatements = map inMarsh (zip3 argsTI ins toCs)-  ret <- newName "res"-  let runstatement = bindS (varP ret) (foldl f z toCs)-  let returnstatement = [| $(checkStatusExp) ( $(outputConv) $(varE ret), $(tupE (map varE outs)) ) |]-  expr <- doE $ concat [instatements, runstatement:outstatements, [noBindS returnstatement]]-  let usedins = map snd . filter (isused . fst) $ zip argsTI ins-  let fdec = FunD fcall [Clause (map VarP usedins) (NormalB expr) []]-  tdec <- sigD fcall $ funTypeMod checkStatusType argsTI-  return [tdec, fdec]-  where-  safeName :: String -> CVar -> Q TH.Name-  safeName end (s:str, _) = newName (toLower s : str ++ end)--  argsTI = functionTypeInfo cf-  (outputConv, _) = c2hs (typeDat rettype)-  (checkStatusExp, checkStatusType) = outMarshall rettype-  isused (TI _ (Left _) _) = True-  isused _ = False-  fcall = mkName fname-  z = varE (mkName foreignname)-  f x e = appE x (varE e)-  inMarsh (ti,e,e') = case hsinput ti of-    Left (Convert t a) -> bindS (varP e') (appE a (varE e))-    Right (Create a)   -> bindS (varP e') a-  collect ( (arg, TI _ _ (Just cleanup), e) : xs) = do-    e' <- safeName "_out" arg-    let outinfo = case cleanup of-          Left (Convert t a) -> (bindS (varP e') (appE a (varE e)), Just (t, e'))-          Right (Destroy a) ->  (noBindS (appE a (varE e)), Nothing)-    ys <- collect xs-    return (outinfo:ys)-  collect (_:xs) = collect xs-  collect [] = return []-  collecti (TI _ (Left (Convert t _)) _) = -    [t]-  collecti _ = []---cublasFile, cusparseFile :: FilePath-cublasFile = CUDA_INCLUDE_DIR </> "cublas_v2.h"-cusparseFile = CUDA_INCLUDE_DIR </> "cusparse_v2.h"---filterMaybes :: [Maybe a] -> [a]-filterMaybes [] = []-filterMaybes (Just x:xs) = x : filterMaybes xs-filterMaybes (Nothing:xs) = filterMaybes xs---funname :: CDeclaration a -> String-funname (CDecl _ [(Just (CDeclr (Just ident ) _ _ _ _), _, _)] _) = identToString ident-funname _ = "Weird!"--desired :: String -> CFunction -> Bool-desired prefix (name, _, _) = -    any (`isPrefixOf` name) $ map (prefix ++) ("Get" : map (:[]) "SDCZX")--infol :: Show a =>  CDerivedDeclarator a -> Maybe [[String]]-infol (CFunDeclr (Right (ys,_)) _ _) = Just $ map f ys where-  f (CDecl specs _ _) = map show specs-infol _ = Nothing--funArgs :: CDeclarator a -> Maybe [CDeclaration a]-funArgs (CDeclr _ [(CFunDeclr (Right (ys,_)) _ _)] _ _ _) = Just ys-funArgs _ = Nothing--funDecl :: CDeclaration a -> Maybe (CDeclarator a)-funDecl (CDecl _ [(Just declarator, _, _)] _) = Just declarator-funDecl _ = Nothing--maybeFunction :: CDeclaration a -> Maybe (CFunction)-maybeFunction d@(CDecl returnType _ _) = do-  args <- funArgs =<< funDecl d-  retName <- declName d-  argNames <- mapM declName args-  let argTypes = map cType args-  return (retName, convert' returnType, zip argNames argTypes )--maybeExternalDec :: CExternalDeclaration a -> Maybe (CDeclaration a)-maybeExternalDec (CDeclExt d) = Just d-maybeExternalDec _ = Nothing--type CVar = (String, TypeC)-type CFunction = ( String , TypeC , [CVar] )--getFunctions :: FilePath -> IO [CFunction]-getFunctions fp = do-  Right (CTranslUnit xs _) <- parseCFile (newGCC "/usr/bin/gcc") Nothing [] fp-  return $ mapMaybe (maybeExternalDec >=> maybeFunction) xs--createf :: FilePath -> CFunction -> Q Dec-createf fp (name, ret, args) = -  forImpD cCall safe{-unsafe-} (fp ++ ' ':name) (mkName name) cFunType-  where-  cFunType = foldr f z (map (ct . typeDat . snd) args)-  z = [t| IO $(ct . typeDat $ ret) |]-  f x y = [t| $(x) -> $(y) |]---sharedDecs :: String -> [CFunction] -> [(String, [(String, CFunction)])]-sharedDecs prefix xs = xs'' where-  g x@(s,ret,args) = do-    newname <- dropc <$> goodName prefix s-    return (s, (newname, ret, args))-  xs' = mapMaybe g xs-  fst3 (s,_,_) = s-  dropc name = if last name == 'c' then init name else name --for dot, ger, ...-  xs'' = map ( (fst3 . snd . head) &&& id) .-    filter sdFilter . groupWith (tail . fst3 . snd) $ xs'-  sdFilter xs = length xs == 4 && not (-    any (`isInfixOf` (fst (head xs))) ["rot_v2", "rotg_v2", "hybsv_analysis", "numericBoost"] )--mkClass :: String -> [CFunction] -> Q Dec-mkClass (p:prefix) xs = classD (return []) className [PlainTV typeName] [] decs where-  className = mkName (toUpper p:prefix)-  typeName = mkName "a"-  decs = map (f . phonifyF) xs-  mkPhony :: TypeC -> TypeC-  mkPhony (PtrC t) = PtrC (mkPhony t)-  mkPhony (ArrC t) = ArrC (mkPhony t)-  mkPhony x = let t' = PhonyC typeName in-    case x of DoubleC -> t'; FloatC -> t'; ComplexC _ -> t'; y -> y-  phonifyF :: CFunction -> CFunction-  phonifyF (name, ret, args) = (name, mkPhony ret, map (second mkPhony) args)-  f cfunc@(name, _, _) = sigD (mkName (tail name)) (funType $ functionTypeInfo cfunc)--mkClassInstances :: String -> [(String, [(String,CFunction)])] -> [Q Dec]-mkClassInstances (p:prefix) xs = map (\c -> makeInstance c $ map (f c) xs) "sdcz" where-  makeInstance c decs = instanceD (return []) classSig (decs) where-    classSig = appT (return . ConT $ mkName (toUpper p:prefix)) (ct . typeDat $ typeMap c)-  f c (_, funcs) = (!! 1) <$> createf' (foreignn, (name, ret, args)) where-    [(foreignn,((_:name), ret, args))] = filter (\(_,((s:_),_,_))-> s==c) funcs--typeMap :: Char -> TypeC-typeMap 'c' = ComplexC FloatC-typeMap 'z' = ComplexC DoubleC-typeMap 'd' = DoubleC-typeMap 's' = FloatC-typeMap _ = error "typeMap: Invalid character"--makeClassDecs :: String -> FilePath -> IO (Q [Dec])-makeClassDecs str fp = do-  sds <- sharedDecs str <$> getFunctions fp-  return $ sequence (mkClass str (map (snd . head . snd) sds) : mkClassInstances str sds)--makeFFIDecs :: String -> FilePath -> IO (Q [Dec])-makeFFIDecs str fp = sequence . map (createf fp) . filter (desired str) <$> getFunctions fp--makeAllFuncs :: String -> FilePath -> IO (Q [Dec])-makeAllFuncs str fp = fmap concat . sequence . mapMaybe (fmap createf' . alter). filter (desired str) <$> getFunctions fp where-  alter (fname, rettype, args) = do-    newname <- goodName str fname-    return (fname, (newname, rettype, args))--goodName :: String -> String -> Maybe String-goodName prefix = f where-  v2suff = "_v2"-  l = length prefix-  f str = if pre == prefix then Just (toLower x : xs) else Nothing-    where-    (pre, name) = splitAt l str-    (name', v2) = splitAt (length name - length v2suff) name-    (x : xs) = if v2 == v2suff then name' else name--doIO :: IO (Q [a]) -> Q [a]-doIO = join . runIO--inTypes :: [TypeInfo] -> [Q Type]-inTypes = mapMaybe f where-  f (TI _ (Left (Convert t _)) _) = Just t-  f _ = Nothing--outTypes :: [TypeInfo] -> [Q Type]-outTypes = mapMaybe f where-  f (TI _ _ (Just (Left (Convert t _)))) = Just t-  f _ = Nothing--functionTypeInfo :: CFunction -> [TypeInfo]-functionTypeInfo (fname, ret, args) = map (typeInfo fname) args--funTypeMod :: (Q Type -> Q Type) -> [TypeInfo] -> Q Type-funTypeMod f args = foldr arrow z ins where-  arrow x y = [t| $(x) -> $(y) |]-  z = [t| IO $( f $ foldl appT (tupleT (length outs)) outs) |]-  [ins, outs] = map ($ args) [inTypes, outTypes]--funType :: [TypeInfo] -> Q Type-funType = funTypeMod id
− Foreign/CUDA/Cublas/Types.chs 
@@ -1,49 +0,0 @@-{-# LANGUAGE CPP                      #-}-{-# LANGUAGE ForeignFunctionInterface #-}--module Foreign.CUDA.Cublas.Types (--  -- * Types-  Handle(..), Status(..),-  Operation(..),-  SideMode(..),FillMode(..), DiagType(..), PointerMode(..), AtomicsMode(..),--) where--import Foreign (Ptr)--#include <cublas_v2.h>-{# context lib="cublas" #}----- | Types--newtype Handle = Handle { useHandle :: {# type cublasHandle_t #}}--{# enum cublasStatus_t as Status-  { underscoreToCase }-  with prefix="CUBLAS_STATUS" deriving (Eq, Show) #}--{# enum cublasOperation_t as Operation-  { underscoreToCase }-  with prefix="CUBLAS_OP" deriving (Eq, Show) #}--{# enum cublasSideMode_t as SideMode-  { underscoreToCase }-  with prefix="CUBLAS" deriving (Eq, Show) #}--{# enum cublasFillMode_t as FillMode-  { underscoreToCase }-  with prefix="CUBLAS_FILL_MODE" deriving (Eq, Show) #}--{# enum cublasDiagType_t as DiagType-  { underscoreToCase }-  with prefix="CUBLAS_DIAG" deriving (Eq, Show) #}--{# enum cublasPointerMode_t as PointerMode-  { underscoreToCase }-  with prefix="CUBLAS_POINTER_MODE" deriving (Eq, Show) #}--{# enum cublasAtomicsMode_t as AtomicsMode-  { underscoreToCase }-  with prefix="CUBLAS_ATOMICS" deriving (Eq, Show) #}
− Foreign/CUDA/Cusparse.hs 
@@ -1,29 +0,0 @@-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE FlexibleInstances #-}--{- |-This module provides the most convenient FFI bindings to the CUSPARSE-library. The names of functions and the role of arguments closely follows-the CUSPARSE C API, which is documented here:--<http://docs.nvidia.com/cuda/cusparse/>--}--module Foreign.CUDA.Cusparse (-  -- * Types-  module Foreign.CUDA.Cusparse.Types,-  -- * Initialization and destruction-  create, destroy,-  -- * BLAS functions-  module Foreign.CUDA.Cusparse,-  -- * Error handling-  module Foreign.CUDA.Cusparse.Error )-where--import Foreign.CUDA.Cublas.TH-import Foreign.CUDA.Cusparse.FFI--import Foreign.CUDA.Cusparse.Types-import Foreign.CUDA.Cusparse.Error--$(doIO $ makeClassDecs "cusparse" cusparseFile)
− Foreign/CUDA/Cusparse/Error.hs 
@@ -1,53 +0,0 @@-{-# LANGUAGE DeriveDataTypeable       #-}--module Foreign.CUDA.Cusparse.Error where-import Foreign.CUDA.Cusparse.Types (Status (..))---- System-import Data.Typeable-import Control.Exception----- Describe each error code----describe :: Status -> String-describe Success         = "success"-describe NotInitialized  = "library not initialised"-describe AllocFailed     = "resource allocation failed"-describe InvalidValue    = "unsupported value or parameter passed to a function"-describe ArchMismatch    = "unsupported on current architecture"-describe MappingError    = "access to GPU memory failed"-describe ExecutionFailed = "execution failed"-describe InternalError   = "internal error"-describe MatrixTypeNotSupported = "matrix type not supported by this function"----- Exceptions ----------------------------------------------------------------------data CUSPARSEException-  = ExitCode  Status-  | UserError String-  deriving Typeable--instance Exception CUSPARSEException--instance Show CUSPARSEException where-  showsPrec _ (ExitCode  s) = showString ("CUSPARSE Exception: " ++ describe s)-  showsPrec _ (UserError s) = showString ("CUSPARSE Exception: " ++ s)----- | Raise a CUSPARSEException in the IO Monad----cusparseError :: String -> IO a-cusparseError s = throwIO (UserError s)----- | Return the results of a function on successful execution, otherwise throw--- an exception with an error string associated with the return code----resultIfOk :: (Status, a) -> IO a-resultIfOk (status,result) =-    case status of-        Success -> return  result-        _       -> throwIO (ExitCode status)-
− Foreign/CUDA/Cusparse/FFI.hs 
@@ -1,9 +0,0 @@-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE ForeignFunctionInterface #-}--module Foreign.CUDA.Cusparse.FFI where-import Foreign.CUDA.Cublas.TH-import Foreign.C.Types--$(doIO $ makeFFIDecs  "cusparse" cusparseFile)-$(doIO $ makeAllFuncs "cusparse" cusparseFile)
− Foreign/CUDA/Cusparse/Types.chs 
@@ -1,86 +0,0 @@-{-# LANGUAGE CPP                      #-}-{-# LANGUAGE ForeignFunctionInterface #-}--module Foreign.CUDA.Cusparse.Types (--  -- * Types-  Handle(..), HybMat(..), MatDescr(..),-  Csrsv2Info(..), Csric02Info (..), Csrilu02Info (..),-  Bsrsv2Info(..), Bsric02Info (..), Bsrilu02Info (..),-  Bsrsm2Info(..),-  SolvePolicy (..),  SolveAnalysisInfo(..),-  Operation(..), Status(..),-  Action(..), Direction(..), FillMode(..), PointerMode(..), DiagType(..),-  IndexBase(..), MatrixType(..), HybPartition(..),--) where--import Foreign (Ptr)--#include <cusparse_v2.h>-{# context lib="cusparse" #}----- | Types----newtype Handle = Handle { useHandle :: {# type cusparseHandle_t #}}--newtype HybMat = HybMat { useHybMat :: {# type cusparseHybMat_t #}}--newtype MatDescr = MatDescr { useMatDescr :: {# type cusparseMatDescr_t #}}--newtype Csrsv2Info = Csrsv2Info { useCsrsv2Info :: {# type csrsv2Info_t #}}-newtype Csric02Info = Csric02Info { useCsric02Info :: {# type csric02Info_t #}}-newtype Csrilu02Info = Csrilu02Info { useCsrilu02Info :: {# type csrilu02Info_t #}}-newtype Bsrsv2Info = Bsrsv2Info { useBsrsv2Info :: {# type bsrsv2Info_t #}}-newtype Bsric02Info = Bsric02Info { useBsric02Info :: {# type bsric02Info_t #}}-newtype Bsrilu02Info = Bsrilu02Info { useBsrilu02Info :: {# type bsrilu02Info_t #}}-newtype Bsrsm2Info = Bsrsm2Info { useBsrsm2Info :: {# type bsrsm2Info_t #}}--newtype SolveAnalysisInfo = SolveAnalysisInfo { useSolveAnalysisInfo :: {# type cusparseSolveAnalysisInfo_t #}}--{# enum cusparseSolvePolicy_t as SolvePolicy-  { underscoreToCase }-  with prefix="CUSPARSE_SOLVE_POLICY" deriving (Eq, Show) #}---{# enum cusparseStatus_t as Status-  { underscoreToCase }-  with prefix="CUSPARSE_STATUS" deriving (Eq, Show) #}--{# enum cusparseAction_t as Action-  { underscoreToCase }-  with prefix="CUSPARSE_ACTION" deriving (Eq, Show) #}--{# enum cusparseDirection_t as Direction-  { underscoreToCase }-  with prefix="CUSPARSE_DIRECTION" deriving (Eq, Show) #}--{# enum cusparseOperation_t as Operation-  { underscoreToCase }-  with prefix="CUSPARSE_OPERATION" deriving (Eq, Show) #}--{# enum cusparseIndexBase_t as IndexBase-  { underscoreToCase }-  with prefix="CUSPARSE_INDEX_BASE" deriving (Eq, Show) #}--{# enum cusparseHybPartition_t as HybPartition-  { underscoreToCase }-  with prefix="CUSPARSE_HYB_PARTITION" deriving (Eq, Show) #}---{# enum cusparseMatrixType_t as MatrixType-  { underscoreToCase }-  with prefix="CUSPARSE_MATRIX_TYPE" deriving (Eq, Show) #}--{# enum cusparseFillMode_t as FillMode-  { underscoreToCase }-  with prefix="CUSPARSE_FILL_MODE" deriving (Eq, Show) #}--{# enum cusparseDiagType_t as DiagType-  { underscoreToCase }-  with prefix="CUSPARSE_DIAG_TYPE" deriving (Eq, Show) #}--{# enum cusparsePointerMode_t as PointerMode-  { underscoreToCase }-  with prefix="CUSPARSE_POINTER_MODE" deriving (Eq, Show) #}
LICENSE view
@@ -1,4 +1,4 @@-Copyright (c) [2012..2014], Trevor L. McDonell, Ben Sherman+Copyright (c) [2012..2013], Trevor L. McDonell  All rights reserved.
+ README.md view
@@ -0,0 +1,15 @@+Haskell FFI Bindings to cuBLAS+==============================++[![Build status](https://travis-ci.org/tmcdonell/cublas.svg?branch=master)](https://travis-ci.org/tmcdonell/cublas)+[![Hackage](https://img.shields.io/hackage/v/cublas.svg)](https://hackage.haskell.org/package/cublas)++The cuBLAS library is an implementation of BLAS (Basic Linear Algebra+Subprograms) for NVIDIA GPUs. This package provides FFI bindings to the+functions of the cuBLAS library. You will need to install the CUDA driver and+developer toolkit:++  <http://developer.nvidia.com/cuda-downloads>++  <http://docs.nvidia.com/cuda/cublas/index.html>+
Setup.hs view
@@ -1,123 +1,208 @@+{-# LANGUAGE CPP               #-}+{-# LANGUAGE FlexibleInstances #-}++#ifndef MIN_VERSION_Cabal+#define MIN_VERSION_Cabal(major1,major2,minor) 0+#endif+ import Distribution.PackageDescription import Distribution.PackageDescription.Parse-import Distribution.Verbosity-import Distribution.System import Distribution.Simple-import Distribution.Simple.Utils-import Distribution.Simple.Setup import Distribution.Simple.Command-import Distribution.Simple.Program import Distribution.Simple.LocalBuildInfo-import Distribution.Simple.PreProcess           hiding (ppC2hs)+import Distribution.Simple.PreProcess+import Distribution.Simple.Program+import Distribution.Simple.Setup+import Distribution.Simple.Utils                                    hiding ( isInfixOf )+import Distribution.System+import Distribution.Verbosity -import Control.Exception-import Control.Monad-import System.Exit-import System.FilePath+#if MIN_VERSION_Cabal(1,25,0)+import Distribution.PackageDescription.PrettyPrint+import Distribution.Version+#endif++import Foreign.CUDA.Path import System.Directory-import System.Environment-import System.IO.Error                          hiding (catch)-import Prelude                                  hiding (catch)+import System.FilePath+import Text.Printf+import Prelude  --- Replicate the invocation of the postConf script, so that we can insert the--- arguments of --extra-include-dirs and --extra-lib-dirs as paths in CPPFLAGS--- and LDFLAGS into the environment+-- Configuration+-- -------------++customBuildInfoFilePath :: FilePath+customBuildInfoFilePath = "cublas" <.> "buildinfo"++generatedBuildInfoFilePath :: FilePath+generatedBuildInfoFilePath = customBuildInfoFilePath <.> "generated"+++-- http://docs.nvidia.com/cuda/cublas/index.html#static-library --+staticLibs :: Platform -> [String]+staticLibs platform@(Platform _arch os) =+  case os of+    Windows -> dynamicLibs platform+    _       -> ["cublas_static", "culibos", "cudart_static", "pthread", "dl"]++dynamicLibs :: Platform -> [String]+dynamicLibs _ = ["cublas"]+++-- Build setup+-- -----------+ main :: IO () main = defaultMainWithHooks customHooks   where-    preprocessors = hookedPreProcessors autoconfUserHooks-    customHooks   = autoconfUserHooks {-      preConf             = preConfHook,-      postConf            = postConfHook,-      hookedPreProcessors = ("chs",ppC2hs) : filter (\x -> fst x /= "chs") preprocessors-    }+    readHook get_verbosity args flags = do+        noExtraFlags args+        getHookedBuildInfo (fromFlag (get_verbosity flags)) -    preConfHook :: Args -> ConfigFlags -> IO HookedBuildInfo-    preConfHook args flags = do-      let verbosity = fromFlag (configVerbosity flags)+    preprocessors = hookedPreProcessors simpleUserHooks -      confExists <- doesFileExist "configure"-      unless confExists $ do-        code <- rawSystemExitCode verbosity "autoconf" []-        case code of-          ExitSuccess   -> return ()-          ExitFailure c -> die $ "autoconf exited with code " ++ show c+    -- Our readHook implementation uses our getHookedBuildInfo. We can't rely on+    -- cabal's autoconfUserHooks since they don't handle user overwrites to+    -- buildinfo like we do.+    --+    customHooks =+      simpleUserHooks+        { preBuild            = preBuildHook -- not using 'readHook' here because 'build' takes extra args+        , preClean            = readHook cleanVerbosity+        , preCopy             = readHook copyVerbosity+        , preInst             = readHook installVerbosity+        , preHscolour         = readHook hscolourVerbosity+        , preHaddock          = readHook haddockVerbosity+        , preReg              = readHook regVerbosity+        , preUnreg            = readHook regVerbosity+        , postConf            = postConfHook+        , hookedPreProcessors = ("chs", pp_c2hs) : filter (\x -> fst x /= "chs") preprocessors+        } -      preConf autoconfUserHooks args flags+    -- The hook just loads the HookedBuildInfo generated by postConfHook, unless+    -- there is user-provided info that overwrites it.+    --+    preBuildHook :: Args -> BuildFlags -> IO HookedBuildInfo+    preBuildHook _ flags = getHookedBuildInfo $ fromFlag $ buildVerbosity flags +    -- The hook scans system in search for CUDA Toolkit. If the toolkit is not+    -- found, an error is raised. Otherwise the toolkit location is used to+    -- create a `cuda.buildinfo.generated` file with all the resulting flags.+    --     postConfHook :: Args -> ConfigFlags -> PackageDescription -> LocalBuildInfo -> IO ()-    postConfHook args flags pkg_descr lbi-      = let verbosity = fromFlag (configVerbosity flags)-        in do-          noExtraFlags args-          confExists <- doesFileExist "configure"-          if confExists-             then runConfigureScript verbosity False flags lbi-             else die "configure script not found."--          pbi <- getHookedBuildInfo verbosity-          let pkg_descr' = updatePackageDescription pbi pkg_descr-          postConf simpleUserHooks args flags pkg_descr' lbi+    postConfHook args flags pkg_descr lbi = do+      let+          verbosity       = fromFlagOrDefault normal (configVerbosity flags)+          profile         = fromFlagOrDefault False  (configProfLib flags)+          currentPlatform = hostPlatform lbi+          compilerId_     = compilerId (compiler lbi)+      --+      noExtraFlags args+      generateAndStoreBuildInfo verbosity profile currentPlatform compilerId_ generatedBuildInfoFilePath+      --+      actualBuildInfoToUse <- getHookedBuildInfo verbosity+      let pkg_descr' = updatePackageDescription actualBuildInfoToUse pkg_descr+      postConf simpleUserHooks args flags pkg_descr' lbi  -runConfigureScript :: Verbosity -> Bool -> ConfigFlags -> LocalBuildInfo -> IO ()-runConfigureScript verbosity backwardsCompatHack flags lbi = do-  env               <- getEnvironment-  (ccProg, ccFlags) <- configureCCompiler verbosity (withPrograms lbi)+-- Generates build info with flags needed for CUDA Toolkit to be properly+-- visible to underlying build tools.+--+libraryBuildInfo :: Bool -> Platform -> Version -> IO HookedBuildInfo+libraryBuildInfo profile platform@(Platform arch os) ghcVersion = do+  let+      -- options for GHC+      extraLibDirs'     = [ cudaLibraryPath ]+      ccOptions'        = [ "-I" ++ cudaIncludePath ]+      ldOptions'        = [ "-L" ++ cudaLibraryPath ]+      ghcOptions        = map ("-optc"++) ccOptions'+                       ++ map ("-optl"++) ldOptions'+                       ++ if os /= Windows && not profile+                            then map ("-optl-Wl,-rpath,"++) extraLibDirs'+                            else [] -  let env' = foldr appendToEnvironment env-               [("CC",       ccProg)-               ,("CFLAGS",   unwords ccFlags)-               ,("CPPFLAGS", unwords $ map ("-I"++) (configExtraIncludeDirs flags))-               ,("LDFLAGS",  unwords $ map ("-L"++) (configExtraLibDirs flags))-               ]+      extraLibs'        = staticLibs platform+      extraGHCiLibs'    = dynamicLibs platform -  handleNoWindowsSH $ rawSystemExitWithEnv verbosity "sh" args env'+      -- options or c2hs+      archFlag          = case arch of+                            I386   -> "-m32"+                            X86_64 -> "-m64"+                            _      -> ""+      emptyCase         = ["-DUSE_EMPTY_CASE" | versionBranch ghcVersion >= [7,8]]+      blocksExtension   = [ "-U__BLOCKS__" | os == OSX ]+      c2hsOptions       = unwords $ map ("--cppopts="++) ("-E" : archFlag : emptyCase ++ blocksExtension)+      c2hsExtraOptions  = ("x-extra-c2hs-options", c2hsOptions) -  where-    args = "configure" : configureArgs backwardsCompatHack flags+      addSystemSpecificOptions :: BuildInfo -> IO BuildInfo+      addSystemSpecificOptions bi =+        case os of+          _ -> return bi -    appendToEnvironment (key, val) [] = [(key, val)]-    appendToEnvironment (key, val) (kv@(k, v) : rest)-     | key == k  = (key, v ++ " " ++ val) : rest-     | otherwise = kv : appendToEnvironment (key, val) rest+  buildInfo' <- addSystemSpecificOptions $ emptyBuildInfo+    { ccOptions      = ccOptions'+    , ldOptions      = ldOptions'+    , extraLibs      = extraLibs'+    , extraGHCiLibs  = extraGHCiLibs'+    , extraLibDirs   = extraLibDirs'+    , options        = [(GHC, ghcOptions) | os /= Windows]+    , customFieldsBI = [c2hsExtraOptions]+    } -    handleNoWindowsSH action-      | buildOS /= Windows-      = action+  return (Just buildInfo', []) -      | otherwise-      = action-          `catch` \ioe -> if isDoesNotExistError ioe-                              then die notFoundMsg-                              else throwIO ioe+generateAndStoreBuildInfo :: Verbosity -> Bool -> Platform -> CompilerId -> FilePath -> IO ()+generateAndStoreBuildInfo verbosity profile platform (CompilerId _ghcFlavor ghcVersion) path =+  storeHookedBuildInfo verbosity path =<< libraryBuildInfo profile platform ghcVersion -    notFoundMsg = "The package has a './configure' script. This requires a "-               ++ "Unix compatibility toolchain such as MinGW+MSYS or Cygwin."+storeHookedBuildInfo :: Verbosity -> FilePath -> HookedBuildInfo -> IO ()+storeHookedBuildInfo verbosity path hbi = do+  notice verbosity $ "Storing parameters to " ++ path+  writeHookedBuildInfo path hbi  +-- Reads user-provided `cuda.buildinfo` if present, otherwise loads `cuda.buildinfo.generated`+-- Outputs message informing about the other possibility.+-- Calls die when neither of the files is available.+-- (generated one should be always present, as it is created in the post-conf step)+-- getHookedBuildInfo :: Verbosity -> IO HookedBuildInfo getHookedBuildInfo verbosity = do-  maybe_infoFile <- defaultHookedPackageDesc-  case maybe_infoFile of-    Nothing       -> return emptyHookedBuildInfo-    Just infoFile -> do-      info verbosity $ "Reading parameters from " ++ infoFile-      readHookedBuildInfo verbosity infoFile+  doesCustomBuildInfoExists <- doesFileExist customBuildInfoFilePath+  if doesCustomBuildInfoExists+    then do+      notice verbosity $ printf "The user-provided buildinfo from file %s will be used. To use default settings, delete this file.\n" customBuildInfoFilePath+      readHookedBuildInfo verbosity customBuildInfoFilePath+    else do+      doesGeneratedBuildInfoExists <- doesFileExist generatedBuildInfoFilePath+      if doesGeneratedBuildInfoExists+        then do+          notice verbosity $ printf "Using build information from '%s'.\n" generatedBuildInfoFilePath+          notice verbosity $ printf "Provide a '%s' file to override this behaviour.\n" customBuildInfoFilePath+          readHookedBuildInfo verbosity generatedBuildInfoFilePath+        else+          die $ printf "Unexpected failure. Neither the default %s nor custom %s exist.\n" generatedBuildInfoFilePath customBuildInfoFilePath   -- Replicate the default C2HS preprocessor hook here, and inject a value for -- extra-c2hs-options, if it was present in the buildinfo file ----- Everything below copied from Distribution.Simple.PreProcess+-- This is largely copied from Distribution.Simple.PreProcess, with some hacks+-- to make it work with different versions of Cabal-the-library. ---ppC2hs :: BuildInfo -> LocalBuildInfo -> PreProcessor-ppC2hs bi lbi-    = PreProcessor {-        platformIndependent = False,-        runPreProcessor     = \(inBaseDir, inRelativeFile)+class PPC2HS f where+  pp_c2hs :: f++instance PPC2HS (BuildInfo -> LocalBuildInfo -> ComponentLocalBuildInfo -> PreProcessor) where+  pp_c2hs bi lbi _ = pp_c2hs bi lbi++instance PPC2HS (BuildInfo -> LocalBuildInfo -> PreProcessor) where+  pp_c2hs bi lbi =+    PreProcessor+      { platformIndependent = False+      , runPreProcessor     = \(inBaseDir, inRelativeFile)                                (outBaseDir, outRelativeFile) verbosity ->           rawSystemProgramConf verbosity c2hsProgram (withPrograms lbi) . filter (not . null) $             maybe [] words (lookup "x-extra-c2hs-options" (customFieldsBI bi))@@ -130,6 +215,32 @@  getCppOptions :: BuildInfo -> LocalBuildInfo -> [String] getCppOptions bi lbi-   =  ["-I" ++ dir | dir <- includeDirs bi]+    = hcDefines (compiler lbi)+   ++ ["-I" ++ dir | dir <- includeDirs bi]    ++ [opt | opt@('-':c:_) <- ccOptions bi, c `elem` "DIU"]++hcDefines :: Compiler -> [String]+hcDefines comp =+  case compilerFlavor comp of+    GHC  -> ["-D__GLASGOW_HASKELL__=" ++ versionInt version]+    JHC  -> ["-D__JHC__=" ++ versionInt version]+    NHC  -> ["-D__NHC__=" ++ versionInt version]+    Hugs -> ["-D__HUGS__"]+    _    -> []+  where version = compilerVersion comp++-- TODO: move this into the compiler abstraction+-- FIXME: this forces GHC's crazy 4.8.2 -> 408 convention on all the other+-- compilers. Check if that's really what they want.+versionInt :: Version -> String+versionInt v =+  case versionBranch v of+    []      -> "1"+    [n]     -> show n+    n1:n2:_ -> printf "%d%02d" n1 n2++#if MIN_VERSION_Cabal(1,25,0)+versionBranch :: Version -> [Int]+versionBranch = versionNumbers+#endif
+ cbits/stubs.h view
@@ -0,0 +1,18 @@+/*+ * Extra bits for CUBLAS bindings+ */++#ifndef C_STUBS_H+#define C_STUBS_H++#ifdef __MINGW32__+#include <host_defines.h>+#undef CUDARTAPI+#define CUDARTAPI __stdcall+#endif++#include <cuda.h>+#include <cublas_v2.h>++#endif /* C_STUBS_H */+
− config.guess 
@@ -1,1526 +0,0 @@-#! /bin/sh-# Attempt to guess a canonical system name.-#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,-#   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008-#   Free Software Foundation, Inc.--timestamp='2008-01-08'--# This file is free software; you can redistribute it and/or modify it-# under the terms of the GNU General Public License as published by-# the Free Software Foundation; either version 2 of the License, or-# (at your option) any later version.-#-# This program is distributed in the hope that it will be useful, but-# WITHOUT ANY WARRANTY; without even the implied warranty of-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU-# General Public License for more details.-#-# You should have received a copy of the GNU General Public License-# along with this program; if not, write to the Free Software-# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA-# 02110-1301, USA.-#-# As a special exception to the GNU General Public License, if you-# distribute this file as part of a program that contains a-# configuration script generated by Autoconf, you may include it under-# the same distribution terms that you use for the rest of that program.---# Originally written by Per Bothner <per@bothner.com>.-# Please send patches to <config-patches@gnu.org>.  Submit a context-# diff and a properly formatted ChangeLog entry.-#-# This script attempts to guess a canonical system name similar to-# config.sub.  If it succeeds, it prints the system name on stdout, and-# exits with 0.  Otherwise, it exits with 1.-#-# The plan is that this can be called by configure scripts if you-# don't specify an explicit build system type.--me=`echo "$0" | sed -e 's,.*/,,'`--usage="\-Usage: $0 [OPTION]--Output the configuration name of the system \`$me' is run on.--Operation modes:-  -h, --help         print this help, then exit-  -t, --time-stamp   print date of last modification, then exit-  -v, --version      print version number, then exit--Report bugs and patches to <config-patches@gnu.org>."--version="\-GNU config.guess ($timestamp)--Originally written by Per Bothner.-Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,-2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.--This is free software; see the source for copying conditions.  There is NO-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."--help="-Try \`$me --help' for more information."--# Parse command line-while test $# -gt 0 ; do-  case $1 in-    --time-stamp | --time* | -t )-       echo "$timestamp" ; exit ;;-    --version | -v )-       echo "$version" ; exit ;;-    --help | --h* | -h )-       echo "$usage"; exit ;;-    -- )     # Stop option processing-       shift; break ;;-    - )	# Use stdin as input.-       break ;;-    -* )-       echo "$me: invalid option $1$help" >&2-       exit 1 ;;-    * )-       break ;;-  esac-done--if test $# != 0; then-  echo "$me: too many arguments$help" >&2-  exit 1-fi--trap 'exit 1' 1 2 15--# CC_FOR_BUILD -- compiler used by this script. Note that the use of a-# compiler to aid in system detection is discouraged as it requires-# temporary files to be created and, as you can see below, it is a-# headache to deal with in a portable fashion.--# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still-# use `HOST_CC' if defined, but it is deprecated.--# Portable tmp directory creation inspired by the Autoconf team.--set_cc_for_build='-trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;-trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;-: ${TMPDIR=/tmp} ;- { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||- { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||- { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||- { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;-dummy=$tmp/dummy ;-tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;-case $CC_FOR_BUILD,$HOST_CC,$CC in- ,,)    echo "int x;" > $dummy.c ;-	for c in cc gcc c89 c99 ; do-	  if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then-	     CC_FOR_BUILD="$c"; break ;-	  fi ;-	done ;-	if test x"$CC_FOR_BUILD" = x ; then-	  CC_FOR_BUILD=no_compiler_found ;-	fi-	;;- ,,*)   CC_FOR_BUILD=$CC ;;- ,*,*)  CC_FOR_BUILD=$HOST_CC ;;-esac ; set_cc_for_build= ;'--# This is needed to find uname on a Pyramid OSx when run in the BSD universe.-# (ghazi@noc.rutgers.edu 1994-08-24)-if (test -f /.attbin/uname) >/dev/null 2>&1 ; then-	PATH=$PATH:/.attbin ; export PATH-fi--UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown-UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown-UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown-UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown--# Note: order is significant - the case branches are not exclusive.--case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in-    *:NetBSD:*:*)-	# NetBSD (nbsd) targets should (where applicable) match one or-	# more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,-	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently-	# switched to ELF, *-*-netbsd* would select the old-	# object file format.  This provides both forward-	# compatibility and a consistent mechanism for selecting the-	# object file format.-	#-	# Note: NetBSD doesn't particularly care about the vendor-	# portion of the name.  We always set it to "unknown".-	sysctl="sysctl -n hw.machine_arch"-	UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \-	    /usr/sbin/$sysctl 2>/dev/null || echo unknown)`-	case "${UNAME_MACHINE_ARCH}" in-	    armeb) machine=armeb-unknown ;;-	    arm*) machine=arm-unknown ;;-	    sh3el) machine=shl-unknown ;;-	    sh3eb) machine=sh-unknown ;;-	    sh5el) machine=sh5le-unknown ;;-	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;-	esac-	# The Operating System including object format, if it has switched-	# to ELF recently, or will in the future.-	case "${UNAME_MACHINE_ARCH}" in-	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)-		eval $set_cc_for_build-		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \-			| grep __ELF__ >/dev/null-		then-		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).-		    # Return netbsd for either.  FIX?-		    os=netbsd-		else-		    os=netbsdelf-		fi-		;;-	    *)-	        os=netbsd-		;;-	esac-	# The OS release-	# Debian GNU/NetBSD machines have a different userland, and-	# thus, need a distinct triplet. However, they do not need-	# kernel version information, so it can be replaced with a-	# suitable tag, in the style of linux-gnu.-	case "${UNAME_VERSION}" in-	    Debian*)-		release='-gnu'-		;;-	    *)-		release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`-		;;-	esac-	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:-	# contains redundant information, the shorter form:-	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.-	echo "${machine}-${os}${release}"-	exit ;;-    *:OpenBSD:*:*)-	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`-	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}-	exit ;;-    *:ekkoBSD:*:*)-	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}-	exit ;;-    *:SolidBSD:*:*)-	echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}-	exit ;;-    macppc:MirBSD:*:*)-	echo powerpc-unknown-mirbsd${UNAME_RELEASE}-	exit ;;-    *:MirBSD:*:*)-	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}-	exit ;;-    alpha:OSF1:*:*)-	case $UNAME_RELEASE in-	*4.0)-		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`-		;;-	*5.*)-	        UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`-		;;-	esac-	# According to Compaq, /usr/sbin/psrinfo has been available on-	# OSF/1 and Tru64 systems produced since 1995.  I hope that-	# covers most systems running today.  This code pipes the CPU-	# types through head -n 1, so we only detect the type of CPU 0.-	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`-	case "$ALPHA_CPU_TYPE" in-	    "EV4 (21064)")-		UNAME_MACHINE="alpha" ;;-	    "EV4.5 (21064)")-		UNAME_MACHINE="alpha" ;;-	    "LCA4 (21066/21068)")-		UNAME_MACHINE="alpha" ;;-	    "EV5 (21164)")-		UNAME_MACHINE="alphaev5" ;;-	    "EV5.6 (21164A)")-		UNAME_MACHINE="alphaev56" ;;-	    "EV5.6 (21164PC)")-		UNAME_MACHINE="alphapca56" ;;-	    "EV5.7 (21164PC)")-		UNAME_MACHINE="alphapca57" ;;-	    "EV6 (21264)")-		UNAME_MACHINE="alphaev6" ;;-	    "EV6.7 (21264A)")-		UNAME_MACHINE="alphaev67" ;;-	    "EV6.8CB (21264C)")-		UNAME_MACHINE="alphaev68" ;;-	    "EV6.8AL (21264B)")-		UNAME_MACHINE="alphaev68" ;;-	    "EV6.8CX (21264D)")-		UNAME_MACHINE="alphaev68" ;;-	    "EV6.9A (21264/EV69A)")-		UNAME_MACHINE="alphaev69" ;;-	    "EV7 (21364)")-		UNAME_MACHINE="alphaev7" ;;-	    "EV7.9 (21364A)")-		UNAME_MACHINE="alphaev79" ;;-	esac-	# A Pn.n version is a patched version.-	# A Vn.n version is a released version.-	# A Tn.n version is a released field test version.-	# A Xn.n version is an unreleased experimental baselevel.-	# 1.2 uses "1.2" for uname -r.-	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`-	exit ;;-    Alpha\ *:Windows_NT*:*)-	# How do we know it's Interix rather than the generic POSIX subsystem?-	# Should we change UNAME_MACHINE based on the output of uname instead-	# of the specific Alpha model?-	echo alpha-pc-interix-	exit ;;-    21064:Windows_NT:50:3)-	echo alpha-dec-winnt3.5-	exit ;;-    Amiga*:UNIX_System_V:4.0:*)-	echo m68k-unknown-sysv4-	exit ;;-    *:[Aa]miga[Oo][Ss]:*:*)-	echo ${UNAME_MACHINE}-unknown-amigaos-	exit ;;-    *:[Mm]orph[Oo][Ss]:*:*)-	echo ${UNAME_MACHINE}-unknown-morphos-	exit ;;-    *:OS/390:*:*)-	echo i370-ibm-openedition-	exit ;;-    *:z/VM:*:*)-	echo s390-ibm-zvmoe-	exit ;;-    *:OS400:*:*)-        echo powerpc-ibm-os400-	exit ;;-    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)-	echo arm-acorn-riscix${UNAME_RELEASE}-	exit ;;-    arm:riscos:*:*|arm:RISCOS:*:*)-	echo arm-unknown-riscos-	exit ;;-    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)-	echo hppa1.1-hitachi-hiuxmpp-	exit ;;-    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)-	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.-	if test "`(/bin/universe) 2>/dev/null`" = att ; then-		echo pyramid-pyramid-sysv3-	else-		echo pyramid-pyramid-bsd-	fi-	exit ;;-    NILE*:*:*:dcosx)-	echo pyramid-pyramid-svr4-	exit ;;-    DRS?6000:unix:4.0:6*)-	echo sparc-icl-nx6-	exit ;;-    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)-	case `/usr/bin/uname -p` in-	    sparc) echo sparc-icl-nx7; exit ;;-	esac ;;-    sun4H:SunOS:5.*:*)-	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`-	exit ;;-    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)-	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`-	exit ;;-    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)-	echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`-	exit ;;-    sun4*:SunOS:6*:*)-	# According to config.sub, this is the proper way to canonicalize-	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but-	# it's likely to be more like Solaris than SunOS4.-	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`-	exit ;;-    sun4*:SunOS:*:*)-	case "`/usr/bin/arch -k`" in-	    Series*|S4*)-		UNAME_RELEASE=`uname -v`-		;;-	esac-	# Japanese Language versions have a version number like `4.1.3-JL'.-	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`-	exit ;;-    sun3*:SunOS:*:*)-	echo m68k-sun-sunos${UNAME_RELEASE}-	exit ;;-    sun*:*:4.2BSD:*)-	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`-	test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3-	case "`/bin/arch`" in-	    sun3)-		echo m68k-sun-sunos${UNAME_RELEASE}-		;;-	    sun4)-		echo sparc-sun-sunos${UNAME_RELEASE}-		;;-	esac-	exit ;;-    aushp:SunOS:*:*)-	echo sparc-auspex-sunos${UNAME_RELEASE}-	exit ;;-    # The situation for MiNT is a little confusing.  The machine name-    # can be virtually everything (everything which is not-    # "atarist" or "atariste" at least should have a processor-    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"-    # to the lowercase version "mint" (or "freemint").  Finally-    # the system name "TOS" denotes a system which is actually not-    # MiNT.  But MiNT is downward compatible to TOS, so this should-    # be no problem.-    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)-        echo m68k-atari-mint${UNAME_RELEASE}-	exit ;;-    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)-	echo m68k-atari-mint${UNAME_RELEASE}-        exit ;;-    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)-        echo m68k-atari-mint${UNAME_RELEASE}-	exit ;;-    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)-        echo m68k-milan-mint${UNAME_RELEASE}-        exit ;;-    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)-        echo m68k-hades-mint${UNAME_RELEASE}-        exit ;;-    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)-        echo m68k-unknown-mint${UNAME_RELEASE}-        exit ;;-    m68k:machten:*:*)-	echo m68k-apple-machten${UNAME_RELEASE}-	exit ;;-    powerpc:machten:*:*)-	echo powerpc-apple-machten${UNAME_RELEASE}-	exit ;;-    RISC*:Mach:*:*)-	echo mips-dec-mach_bsd4.3-	exit ;;-    RISC*:ULTRIX:*:*)-	echo mips-dec-ultrix${UNAME_RELEASE}-	exit ;;-    VAX*:ULTRIX*:*:*)-	echo vax-dec-ultrix${UNAME_RELEASE}-	exit ;;-    2020:CLIX:*:* | 2430:CLIX:*:*)-	echo clipper-intergraph-clix${UNAME_RELEASE}-	exit ;;-    mips:*:*:UMIPS | mips:*:*:RISCos)-	eval $set_cc_for_build-	sed 's/^	//' << EOF >$dummy.c-#ifdef __cplusplus-#include <stdio.h>  /* for printf() prototype */-	int main (int argc, char *argv[]) {-#else-	int main (argc, argv) int argc; char *argv[]; {-#endif-	#if defined (host_mips) && defined (MIPSEB)-	#if defined (SYSTYPE_SYSV)-	  printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);-	#endif-	#if defined (SYSTYPE_SVR4)-	  printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);-	#endif-	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)-	  printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);-	#endif-	#endif-	  exit (-1);-	}-EOF-	$CC_FOR_BUILD -o $dummy $dummy.c &&-	  dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&-	  SYSTEM_NAME=`$dummy $dummyarg` &&-	    { echo "$SYSTEM_NAME"; exit; }-	echo mips-mips-riscos${UNAME_RELEASE}-	exit ;;-    Motorola:PowerMAX_OS:*:*)-	echo powerpc-motorola-powermax-	exit ;;-    Motorola:*:4.3:PL8-*)-	echo powerpc-harris-powermax-	exit ;;-    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)-	echo powerpc-harris-powermax-	exit ;;-    Night_Hawk:Power_UNIX:*:*)-	echo powerpc-harris-powerunix-	exit ;;-    m88k:CX/UX:7*:*)-	echo m88k-harris-cxux7-	exit ;;-    m88k:*:4*:R4*)-	echo m88k-motorola-sysv4-	exit ;;-    m88k:*:3*:R3*)-	echo m88k-motorola-sysv3-	exit ;;-    AViiON:dgux:*:*)-        # DG/UX returns AViiON for all architectures-        UNAME_PROCESSOR=`/usr/bin/uname -p`-	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]-	then-	    if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \-	       [ ${TARGET_BINARY_INTERFACE}x = x ]-	    then-		echo m88k-dg-dgux${UNAME_RELEASE}-	    else-		echo m88k-dg-dguxbcs${UNAME_RELEASE}-	    fi-	else-	    echo i586-dg-dgux${UNAME_RELEASE}-	fi- 	exit ;;-    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)-	echo m88k-dolphin-sysv3-	exit ;;-    M88*:*:R3*:*)-	# Delta 88k system running SVR3-	echo m88k-motorola-sysv3-	exit ;;-    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)-	echo m88k-tektronix-sysv3-	exit ;;-    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)-	echo m68k-tektronix-bsd-	exit ;;-    *:IRIX*:*:*)-	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`-	exit ;;-    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.-	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id-	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '-    i*86:AIX:*:*)-	echo i386-ibm-aix-	exit ;;-    ia64:AIX:*:*)-	if [ -x /usr/bin/oslevel ] ; then-		IBM_REV=`/usr/bin/oslevel`-	else-		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}-	fi-	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}-	exit ;;-    *:AIX:2:3)-	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then-		eval $set_cc_for_build-		sed 's/^		//' << EOF >$dummy.c-		#include <sys/systemcfg.h>--		main()-			{-			if (!__power_pc())-				exit(1);-			puts("powerpc-ibm-aix3.2.5");-			exit(0);-			}-EOF-		if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`-		then-			echo "$SYSTEM_NAME"-		else-			echo rs6000-ibm-aix3.2.5-		fi-	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then-		echo rs6000-ibm-aix3.2.4-	else-		echo rs6000-ibm-aix3.2-	fi-	exit ;;-    *:AIX:*:[456])-	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`-	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then-		IBM_ARCH=rs6000-	else-		IBM_ARCH=powerpc-	fi-	if [ -x /usr/bin/oslevel ] ; then-		IBM_REV=`/usr/bin/oslevel`-	else-		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}-	fi-	echo ${IBM_ARCH}-ibm-aix${IBM_REV}-	exit ;;-    *:AIX:*:*)-	echo rs6000-ibm-aix-	exit ;;-    ibmrt:4.4BSD:*|romp-ibm:BSD:*)-	echo romp-ibm-bsd4.4-	exit ;;-    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and-	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to-	exit ;;                             # report: romp-ibm BSD 4.3-    *:BOSX:*:*)-	echo rs6000-bull-bosx-	exit ;;-    DPX/2?00:B.O.S.:*:*)-	echo m68k-bull-sysv3-	exit ;;-    9000/[34]??:4.3bsd:1.*:*)-	echo m68k-hp-bsd-	exit ;;-    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)-	echo m68k-hp-bsd4.4-	exit ;;-    9000/[34678]??:HP-UX:*:*)-	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`-	case "${UNAME_MACHINE}" in-	    9000/31? )            HP_ARCH=m68000 ;;-	    9000/[34]?? )         HP_ARCH=m68k ;;-	    9000/[678][0-9][0-9])-		if [ -x /usr/bin/getconf ]; then-		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`-                    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`-                    case "${sc_cpu_version}" in-                      523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0-                      528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1-                      532)                      # CPU_PA_RISC2_0-                        case "${sc_kernel_bits}" in-                          32) HP_ARCH="hppa2.0n" ;;-                          64) HP_ARCH="hppa2.0w" ;;-			  '') HP_ARCH="hppa2.0" ;;   # HP-UX 10.20-                        esac ;;-                    esac-		fi-		if [ "${HP_ARCH}" = "" ]; then-		    eval $set_cc_for_build-		    sed 's/^              //' << EOF >$dummy.c--              #define _HPUX_SOURCE-              #include <stdlib.h>-              #include <unistd.h>--              int main ()-              {-              #if defined(_SC_KERNEL_BITS)-                  long bits = sysconf(_SC_KERNEL_BITS);-              #endif-                  long cpu  = sysconf (_SC_CPU_VERSION);--                  switch (cpu)-              	{-              	case CPU_PA_RISC1_0: puts ("hppa1.0"); break;-              	case CPU_PA_RISC1_1: puts ("hppa1.1"); break;-              	case CPU_PA_RISC2_0:-              #if defined(_SC_KERNEL_BITS)-              	    switch (bits)-              		{-              		case 64: puts ("hppa2.0w"); break;-              		case 32: puts ("hppa2.0n"); break;-              		default: puts ("hppa2.0"); break;-              		} break;-              #else  /* !defined(_SC_KERNEL_BITS) */-              	    puts ("hppa2.0"); break;-              #endif-              	default: puts ("hppa1.0"); break;-              	}-                  exit (0);-              }-EOF-		    (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`-		    test -z "$HP_ARCH" && HP_ARCH=hppa-		fi ;;-	esac-	if [ ${HP_ARCH} = "hppa2.0w" ]-	then-	    eval $set_cc_for_build--	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating-	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler-	    # generating 64-bit code.  GNU and HP use different nomenclature:-	    #-	    # $ CC_FOR_BUILD=cc ./config.guess-	    # => hppa2.0w-hp-hpux11.23-	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess-	    # => hppa64-hp-hpux11.23--	    if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |-		grep __LP64__ >/dev/null-	    then-		HP_ARCH="hppa2.0w"-	    else-		HP_ARCH="hppa64"-	    fi-	fi-	echo ${HP_ARCH}-hp-hpux${HPUX_REV}-	exit ;;-    ia64:HP-UX:*:*)-	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`-	echo ia64-hp-hpux${HPUX_REV}-	exit ;;-    3050*:HI-UX:*:*)-	eval $set_cc_for_build-	sed 's/^	//' << EOF >$dummy.c-	#include <unistd.h>-	int-	main ()-	{-	  long cpu = sysconf (_SC_CPU_VERSION);-	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns-	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct-	     results, however.  */-	  if (CPU_IS_PA_RISC (cpu))-	    {-	      switch (cpu)-		{-		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;-		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;-		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;-		  default: puts ("hppa-hitachi-hiuxwe2"); break;-		}-	    }-	  else if (CPU_IS_HP_MC68K (cpu))-	    puts ("m68k-hitachi-hiuxwe2");-	  else puts ("unknown-hitachi-hiuxwe2");-	  exit (0);-	}-EOF-	$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&-		{ echo "$SYSTEM_NAME"; exit; }-	echo unknown-hitachi-hiuxwe2-	exit ;;-    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )-	echo hppa1.1-hp-bsd-	exit ;;-    9000/8??:4.3bsd:*:*)-	echo hppa1.0-hp-bsd-	exit ;;-    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)-	echo hppa1.0-hp-mpeix-	exit ;;-    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )-	echo hppa1.1-hp-osf-	exit ;;-    hp8??:OSF1:*:*)-	echo hppa1.0-hp-osf-	exit ;;-    i*86:OSF1:*:*)-	if [ -x /usr/sbin/sysversion ] ; then-	    echo ${UNAME_MACHINE}-unknown-osf1mk-	else-	    echo ${UNAME_MACHINE}-unknown-osf1-	fi-	exit ;;-    parisc*:Lites*:*:*)-	echo hppa1.1-hp-lites-	exit ;;-    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)-	echo c1-convex-bsd-        exit ;;-    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)-	if getsysinfo -f scalar_acc-	then echo c32-convex-bsd-	else echo c2-convex-bsd-	fi-        exit ;;-    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)-	echo c34-convex-bsd-        exit ;;-    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)-	echo c38-convex-bsd-        exit ;;-    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)-	echo c4-convex-bsd-        exit ;;-    CRAY*Y-MP:*:*:*)-	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'-	exit ;;-    CRAY*[A-Z]90:*:*:*)-	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \-	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \-	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \-	      -e 's/\.[^.]*$/.X/'-	exit ;;-    CRAY*TS:*:*:*)-	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'-	exit ;;-    CRAY*T3E:*:*:*)-	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'-	exit ;;-    CRAY*SV1:*:*:*)-	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'-	exit ;;-    *:UNICOS/mp:*:*)-	echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'-	exit ;;-    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)-	FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`-        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`-        FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`-        echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"-        exit ;;-    5000:UNIX_System_V:4.*:*)-        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`-        FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`-        echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"-	exit ;;-    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)-	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}-	exit ;;-    sparc*:BSD/OS:*:*)-	echo sparc-unknown-bsdi${UNAME_RELEASE}-	exit ;;-    *:BSD/OS:*:*)-	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}-	exit ;;-    *:FreeBSD:*:*)-	case ${UNAME_MACHINE} in-	    pc98)-		echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;-	    amd64)-		echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;-	    *)-		echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;-	esac-	exit ;;-    i*:CYGWIN*:*)-	echo ${UNAME_MACHINE}-pc-cygwin-	exit ;;-    *:MINGW*:*)-	echo ${UNAME_MACHINE}-pc-mingw32-	exit ;;-    i*:windows32*:*)-    	# uname -m includes "-pc" on this system.-    	echo ${UNAME_MACHINE}-mingw32-	exit ;;-    i*:PW*:*)-	echo ${UNAME_MACHINE}-pc-pw32-	exit ;;-    *:Interix*:[3456]*)-    	case ${UNAME_MACHINE} in-	    x86)-		echo i586-pc-interix${UNAME_RELEASE}-		exit ;;-	    EM64T | authenticamd)-		echo x86_64-unknown-interix${UNAME_RELEASE}-		exit ;;-	    IA64)-		echo ia64-unknown-interix${UNAME_RELEASE}-		exit ;;-	esac ;;-    [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)-	echo i${UNAME_MACHINE}-pc-mks-	exit ;;-    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)-	# How do we know it's Interix rather than the generic POSIX subsystem?-	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we-	# UNAME_MACHINE based on the output of uname instead of i386?-	echo i586-pc-interix-	exit ;;-    i*:UWIN*:*)-	echo ${UNAME_MACHINE}-pc-uwin-	exit ;;-    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)-	echo x86_64-unknown-cygwin-	exit ;;-    p*:CYGWIN*:*)-	echo powerpcle-unknown-cygwin-	exit ;;-    prep*:SunOS:5.*:*)-	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`-	exit ;;-    *:GNU:*:*)-	# the GNU system-	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`-	exit ;;-    *:GNU/*:*:*)-	# other systems with GNU libc and userland-	echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu-	exit ;;-    i*86:Minix:*:*)-	echo ${UNAME_MACHINE}-pc-minix-	exit ;;-    arm*:Linux:*:*)-	eval $set_cc_for_build-	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \-	    | grep -q __ARM_EABI__-	then-	    echo ${UNAME_MACHINE}-unknown-linux-gnu-	else-	    echo ${UNAME_MACHINE}-unknown-linux-gnueabi-	fi-	exit ;;-    avr32*:Linux:*:*)-	echo ${UNAME_MACHINE}-unknown-linux-gnu-	exit ;;-    cris:Linux:*:*)-	echo cris-axis-linux-gnu-	exit ;;-    crisv32:Linux:*:*)-	echo crisv32-axis-linux-gnu-	exit ;;-    frv:Linux:*:*)-    	echo frv-unknown-linux-gnu-	exit ;;-    ia64:Linux:*:*)-	echo ${UNAME_MACHINE}-unknown-linux-gnu-	exit ;;-    m32r*:Linux:*:*)-	echo ${UNAME_MACHINE}-unknown-linux-gnu-	exit ;;-    m68*:Linux:*:*)-	echo ${UNAME_MACHINE}-unknown-linux-gnu-	exit ;;-    mips:Linux:*:*)-	eval $set_cc_for_build-	sed 's/^	//' << EOF >$dummy.c-	#undef CPU-	#undef mips-	#undef mipsel-	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)-	CPU=mipsel-	#else-	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)-	CPU=mips-	#else-	CPU=-	#endif-	#endif-EOF-	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '-	    /^CPU/{-		s: ::g-		p-	    }'`"-	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }-	;;-    mips64:Linux:*:*)-	eval $set_cc_for_build-	sed 's/^	//' << EOF >$dummy.c-	#undef CPU-	#undef mips64-	#undef mips64el-	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)-	CPU=mips64el-	#else-	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)-	CPU=mips64-	#else-	CPU=-	#endif-	#endif-EOF-	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '-	    /^CPU/{-		s: ::g-		p-	    }'`"-	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }-	;;-    or32:Linux:*:*)-	echo or32-unknown-linux-gnu-	exit ;;-    ppc:Linux:*:*)-	echo powerpc-unknown-linux-gnu-	exit ;;-    ppc64:Linux:*:*)-	echo powerpc64-unknown-linux-gnu-	exit ;;-    alpha:Linux:*:*)-	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in-	  EV5)   UNAME_MACHINE=alphaev5 ;;-	  EV56)  UNAME_MACHINE=alphaev56 ;;-	  PCA56) UNAME_MACHINE=alphapca56 ;;-	  PCA57) UNAME_MACHINE=alphapca56 ;;-	  EV6)   UNAME_MACHINE=alphaev6 ;;-	  EV67)  UNAME_MACHINE=alphaev67 ;;-	  EV68*) UNAME_MACHINE=alphaev68 ;;-        esac-	objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null-	if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi-	echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}-	exit ;;-    parisc:Linux:*:* | hppa:Linux:*:*)-	# Look for CPU level-	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in-	  PA7*) echo hppa1.1-unknown-linux-gnu ;;-	  PA8*) echo hppa2.0-unknown-linux-gnu ;;-	  *)    echo hppa-unknown-linux-gnu ;;-	esac-	exit ;;-    parisc64:Linux:*:* | hppa64:Linux:*:*)-	echo hppa64-unknown-linux-gnu-	exit ;;-    s390:Linux:*:* | s390x:Linux:*:*)-	echo ${UNAME_MACHINE}-ibm-linux-	exit ;;-    sh64*:Linux:*:*)-    	echo ${UNAME_MACHINE}-unknown-linux-gnu-	exit ;;-    sh*:Linux:*:*)-	echo ${UNAME_MACHINE}-unknown-linux-gnu-	exit ;;-    sparc:Linux:*:* | sparc64:Linux:*:*)-	echo ${UNAME_MACHINE}-unknown-linux-gnu-	exit ;;-    vax:Linux:*:*)-	echo ${UNAME_MACHINE}-dec-linux-gnu-	exit ;;-    x86_64:Linux:*:*)-	echo x86_64-unknown-linux-gnu-	exit ;;-    xtensa*:Linux:*:*)-    	echo ${UNAME_MACHINE}-unknown-linux-gnu-	exit ;;-    i*86:Linux:*:*)-	# The BFD linker knows what the default object file format is, so-	# first see if it will tell us. cd to the root directory to prevent-	# problems with other programs or directories called `ld' in the path.-	# Set LC_ALL=C to ensure ld outputs messages in English.-	ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \-			 | sed -ne '/supported targets:/!d-				    s/[ 	][ 	]*/ /g-				    s/.*supported targets: *//-				    s/ .*//-				    p'`-        case "$ld_supported_targets" in-	  elf32-i386)-		TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"-		;;-	  a.out-i386-linux)-		echo "${UNAME_MACHINE}-pc-linux-gnuaout"-		exit ;;-	  coff-i386)-		echo "${UNAME_MACHINE}-pc-linux-gnucoff"-		exit ;;-	  "")-		# Either a pre-BFD a.out linker (linux-gnuoldld) or-		# one that does not give us useful --help.-		echo "${UNAME_MACHINE}-pc-linux-gnuoldld"-		exit ;;-	esac-	# Determine whether the default compiler is a.out or elf-	eval $set_cc_for_build-	sed 's/^	//' << EOF >$dummy.c-	#include <features.h>-	#ifdef __ELF__-	# ifdef __GLIBC__-	#  if __GLIBC__ >= 2-	LIBC=gnu-	#  else-	LIBC=gnulibc1-	#  endif-	# else-	LIBC=gnulibc1-	# endif-	#else-	#if defined(__INTEL_COMPILER) || defined(__PGI) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)-	LIBC=gnu-	#else-	LIBC=gnuaout-	#endif-	#endif-	#ifdef __dietlibc__-	LIBC=dietlibc-	#endif-EOF-	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '-	    /^LIBC/{-		s: ::g-		p-	    }'`"-	test x"${LIBC}" != x && {-		echo "${UNAME_MACHINE}-pc-linux-${LIBC}"-		exit-	}-	test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; }-	;;-    i*86:DYNIX/ptx:4*:*)-	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.-	# earlier versions are messed up and put the nodename in both-	# sysname and nodename.-	echo i386-sequent-sysv4-	exit ;;-    i*86:UNIX_SV:4.2MP:2.*)-        # Unixware is an offshoot of SVR4, but it has its own version-        # number series starting with 2...-        # I am not positive that other SVR4 systems won't match this,-	# I just have to hope.  -- rms.-        # Use sysv4.2uw... so that sysv4* matches it.-	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}-	exit ;;-    i*86:OS/2:*:*)-	# If we were able to find `uname', then EMX Unix compatibility-	# is probably installed.-	echo ${UNAME_MACHINE}-pc-os2-emx-	exit ;;-    i*86:XTS-300:*:STOP)-	echo ${UNAME_MACHINE}-unknown-stop-	exit ;;-    i*86:atheos:*:*)-	echo ${UNAME_MACHINE}-unknown-atheos-	exit ;;-    i*86:syllable:*:*)-	echo ${UNAME_MACHINE}-pc-syllable-	exit ;;-    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)-	echo i386-unknown-lynxos${UNAME_RELEASE}-	exit ;;-    i*86:*DOS:*:*)-	echo ${UNAME_MACHINE}-pc-msdosdjgpp-	exit ;;-    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)-	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`-	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then-		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}-	else-		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}-	fi-	exit ;;-    i*86:*:5:[678]*)-    	# UnixWare 7.x, OpenUNIX and OpenServer 6.-	case `/bin/uname -X | grep "^Machine"` in-	    *486*)	     UNAME_MACHINE=i486 ;;-	    *Pentium)	     UNAME_MACHINE=i586 ;;-	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;-	esac-	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}-	exit ;;-    i*86:*:3.2:*)-	if test -f /usr/options/cb.name; then-		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`-		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL-	elif /bin/uname -X 2>/dev/null >/dev/null ; then-		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`-		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486-		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \-			&& UNAME_MACHINE=i586-		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \-			&& UNAME_MACHINE=i686-		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \-			&& UNAME_MACHINE=i686-		echo ${UNAME_MACHINE}-pc-sco$UNAME_REL-	else-		echo ${UNAME_MACHINE}-pc-sysv32-	fi-	exit ;;-    pc:*:*:*)-	# Left here for compatibility:-        # uname -m prints for DJGPP always 'pc', but it prints nothing about-        # the processor, so we play safe by assuming i386.-	echo i386-pc-msdosdjgpp-        exit ;;-    Intel:Mach:3*:*)-	echo i386-pc-mach3-	exit ;;-    paragon:*:*:*)-	echo i860-intel-osf1-	exit ;;-    i860:*:4.*:*) # i860-SVR4-	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then-	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4-	else # Add other i860-SVR4 vendors below as they are discovered.-	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4-	fi-	exit ;;-    mini*:CTIX:SYS*5:*)-	# "miniframe"-	echo m68010-convergent-sysv-	exit ;;-    mc68k:UNIX:SYSTEM5:3.51m)-	echo m68k-convergent-sysv-	exit ;;-    M680?0:D-NIX:5.3:*)-	echo m68k-diab-dnix-	exit ;;-    M68*:*:R3V[5678]*:*)-	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;-    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)-	OS_REL=''-	test -r /etc/.relid \-	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \-	  && { echo i486-ncr-sysv4.3${OS_REL}; exit; }-	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \-	  && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;-    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)-        /bin/uname -p 2>/dev/null | grep 86 >/dev/null \-          && { echo i486-ncr-sysv4; exit; } ;;-    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)-	echo m68k-unknown-lynxos${UNAME_RELEASE}-	exit ;;-    mc68030:UNIX_System_V:4.*:*)-	echo m68k-atari-sysv4-	exit ;;-    TSUNAMI:LynxOS:2.*:*)-	echo sparc-unknown-lynxos${UNAME_RELEASE}-	exit ;;-    rs6000:LynxOS:2.*:*)-	echo rs6000-unknown-lynxos${UNAME_RELEASE}-	exit ;;-    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)-	echo powerpc-unknown-lynxos${UNAME_RELEASE}-	exit ;;-    SM[BE]S:UNIX_SV:*:*)-	echo mips-dde-sysv${UNAME_RELEASE}-	exit ;;-    RM*:ReliantUNIX-*:*:*)-	echo mips-sni-sysv4-	exit ;;-    RM*:SINIX-*:*:*)-	echo mips-sni-sysv4-	exit ;;-    *:SINIX-*:*:*)-	if uname -p 2>/dev/null >/dev/null ; then-		UNAME_MACHINE=`(uname -p) 2>/dev/null`-		echo ${UNAME_MACHINE}-sni-sysv4-	else-		echo ns32k-sni-sysv-	fi-	exit ;;-    PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort-                      # says <Richard.M.Bartel@ccMail.Census.GOV>-        echo i586-unisys-sysv4-        exit ;;-    *:UNIX_System_V:4*:FTX*)-	# From Gerald Hewes <hewes@openmarket.com>.-	# How about differentiating between stratus architectures? -djm-	echo hppa1.1-stratus-sysv4-	exit ;;-    *:*:*:FTX*)-	# From seanf@swdc.stratus.com.-	echo i860-stratus-sysv4-	exit ;;-    i*86:VOS:*:*)-	# From Paul.Green@stratus.com.-	echo ${UNAME_MACHINE}-stratus-vos-	exit ;;-    *:VOS:*:*)-	# From Paul.Green@stratus.com.-	echo hppa1.1-stratus-vos-	exit ;;-    mc68*:A/UX:*:*)-	echo m68k-apple-aux${UNAME_RELEASE}-	exit ;;-    news*:NEWS-OS:6*:*)-	echo mips-sony-newsos6-	exit ;;-    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)-	if [ -d /usr/nec ]; then-	        echo mips-nec-sysv${UNAME_RELEASE}-	else-	        echo mips-unknown-sysv${UNAME_RELEASE}-	fi-        exit ;;-    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.-	echo powerpc-be-beos-	exit ;;-    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.-	echo powerpc-apple-beos-	exit ;;-    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.-	echo i586-pc-beos-	exit ;;-    SX-4:SUPER-UX:*:*)-	echo sx4-nec-superux${UNAME_RELEASE}-	exit ;;-    SX-5:SUPER-UX:*:*)-	echo sx5-nec-superux${UNAME_RELEASE}-	exit ;;-    SX-6:SUPER-UX:*:*)-	echo sx6-nec-superux${UNAME_RELEASE}-	exit ;;-    SX-7:SUPER-UX:*:*)-	echo sx7-nec-superux${UNAME_RELEASE}-	exit ;;-    SX-8:SUPER-UX:*:*)-	echo sx8-nec-superux${UNAME_RELEASE}-	exit ;;-    SX-8R:SUPER-UX:*:*)-	echo sx8r-nec-superux${UNAME_RELEASE}-	exit ;;-    Power*:Rhapsody:*:*)-	echo powerpc-apple-rhapsody${UNAME_RELEASE}-	exit ;;-    *:Rhapsody:*:*)-	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}-	exit ;;-    *:Darwin:*:*)-	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown-	case $UNAME_PROCESSOR in-	    unknown) UNAME_PROCESSOR=powerpc ;;-	esac-	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}-	exit ;;-    *:procnto*:*:* | *:QNX:[0123456789]*:*)-	UNAME_PROCESSOR=`uname -p`-	if test "$UNAME_PROCESSOR" = "x86"; then-		UNAME_PROCESSOR=i386-		UNAME_MACHINE=pc-	fi-	echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}-	exit ;;-    *:QNX:*:4*)-	echo i386-pc-qnx-	exit ;;-    NSE-?:NONSTOP_KERNEL:*:*)-	echo nse-tandem-nsk${UNAME_RELEASE}-	exit ;;-    NSR-?:NONSTOP_KERNEL:*:*)-	echo nsr-tandem-nsk${UNAME_RELEASE}-	exit ;;-    *:NonStop-UX:*:*)-	echo mips-compaq-nonstopux-	exit ;;-    BS2000:POSIX*:*:*)-	echo bs2000-siemens-sysv-	exit ;;-    DS/*:UNIX_System_V:*:*)-	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}-	exit ;;-    *:Plan9:*:*)-	# "uname -m" is not consistent, so use $cputype instead. 386-	# is converted to i386 for consistency with other x86-	# operating systems.-	if test "$cputype" = "386"; then-	    UNAME_MACHINE=i386-	else-	    UNAME_MACHINE="$cputype"-	fi-	echo ${UNAME_MACHINE}-unknown-plan9-	exit ;;-    *:TOPS-10:*:*)-	echo pdp10-unknown-tops10-	exit ;;-    *:TENEX:*:*)-	echo pdp10-unknown-tenex-	exit ;;-    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)-	echo pdp10-dec-tops20-	exit ;;-    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)-	echo pdp10-xkl-tops20-	exit ;;-    *:TOPS-20:*:*)-	echo pdp10-unknown-tops20-	exit ;;-    *:ITS:*:*)-	echo pdp10-unknown-its-	exit ;;-    SEI:*:*:SEIUX)-        echo mips-sei-seiux${UNAME_RELEASE}-	exit ;;-    *:DragonFly:*:*)-	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-	exit ;;-    *:*VMS:*:*)-    	UNAME_MACHINE=`(uname -p) 2>/dev/null`-	case "${UNAME_MACHINE}" in-	    A*) echo alpha-dec-vms ; exit ;;-	    I*) echo ia64-dec-vms ; exit ;;-	    V*) echo vax-dec-vms ; exit ;;-	esac ;;-    *:XENIX:*:SysV)-	echo i386-pc-xenix-	exit ;;-    i*86:skyos:*:*)-	echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'-	exit ;;-    i*86:rdos:*:*)-	echo ${UNAME_MACHINE}-pc-rdos-	exit ;;-esac--#echo '(No uname command or uname output not recognized.)' 1>&2-#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2--eval $set_cc_for_build-cat >$dummy.c <<EOF-#ifdef _SEQUENT_-# include <sys/types.h>-# include <sys/utsname.h>-#endif-main ()-{-#if defined (sony)-#if defined (MIPSEB)-  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,-     I don't know....  */-  printf ("mips-sony-bsd\n"); exit (0);-#else-#include <sys/param.h>-  printf ("m68k-sony-newsos%s\n",-#ifdef NEWSOS4-          "4"-#else-	  ""-#endif-         ); exit (0);-#endif-#endif--#if defined (__arm) && defined (__acorn) && defined (__unix)-  printf ("arm-acorn-riscix\n"); exit (0);-#endif--#if defined (hp300) && !defined (hpux)-  printf ("m68k-hp-bsd\n"); exit (0);-#endif--#if defined (NeXT)-#if !defined (__ARCHITECTURE__)-#define __ARCHITECTURE__ "m68k"-#endif-  int version;-  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;-  if (version < 4)-    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);-  else-    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);-  exit (0);-#endif--#if defined (MULTIMAX) || defined (n16)-#if defined (UMAXV)-  printf ("ns32k-encore-sysv\n"); exit (0);-#else-#if defined (CMU)-  printf ("ns32k-encore-mach\n"); exit (0);-#else-  printf ("ns32k-encore-bsd\n"); exit (0);-#endif-#endif-#endif--#if defined (__386BSD__)-  printf ("i386-pc-bsd\n"); exit (0);-#endif--#if defined (sequent)-#if defined (i386)-  printf ("i386-sequent-dynix\n"); exit (0);-#endif-#if defined (ns32000)-  printf ("ns32k-sequent-dynix\n"); exit (0);-#endif-#endif--#if defined (_SEQUENT_)-    struct utsname un;--    uname(&un);--    if (strncmp(un.version, "V2", 2) == 0) {-	printf ("i386-sequent-ptx2\n"); exit (0);-    }-    if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */-	printf ("i386-sequent-ptx1\n"); exit (0);-    }-    printf ("i386-sequent-ptx\n"); exit (0);--#endif--#if defined (vax)-# if !defined (ultrix)-#  include <sys/param.h>-#  if defined (BSD)-#   if BSD == 43-      printf ("vax-dec-bsd4.3\n"); exit (0);-#   else-#    if BSD == 199006-      printf ("vax-dec-bsd4.3reno\n"); exit (0);-#    else-      printf ("vax-dec-bsd\n"); exit (0);-#    endif-#   endif-#  else-    printf ("vax-dec-bsd\n"); exit (0);-#  endif-# else-    printf ("vax-dec-ultrix\n"); exit (0);-# endif-#endif--#if defined (alliant) && defined (i860)-  printf ("i860-alliant-bsd\n"); exit (0);-#endif--  exit (1);-}-EOF--$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&-	{ echo "$SYSTEM_NAME"; exit; }--# Apollos put the system type in the environment.--test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }--# Convex versions that predate uname can use getsysinfo(1)--if [ -x /usr/convex/getsysinfo ]-then-    case `getsysinfo -f cpu_type` in-    c1*)-	echo c1-convex-bsd-	exit ;;-    c2*)-	if getsysinfo -f scalar_acc-	then echo c32-convex-bsd-	else echo c2-convex-bsd-	fi-	exit ;;-    c34*)-	echo c34-convex-bsd-	exit ;;-    c38*)-	echo c38-convex-bsd-	exit ;;-    c4*)-	echo c4-convex-bsd-	exit ;;-    esac-fi--cat >&2 <<EOF-$0: unable to guess system type--This script, last modified $timestamp, has failed to recognize-the operating system you are using. It is advised that you-download the most up to date version of the config scripts from--  http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.guess-and-  http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.sub--If the version you run ($0) is already up to date, please-send the following data and any information you think might be-pertinent to <config-patches@gnu.org> in order to provide the needed-information to handle your system.--config.guess timestamp = $timestamp--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`-/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`--hostinfo               = `(hostinfo) 2>/dev/null`-/bin/universe          = `(/bin/universe) 2>/dev/null`-/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`-/bin/arch              = `(/bin/arch) 2>/dev/null`-/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`-/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`--UNAME_MACHINE = ${UNAME_MACHINE}-UNAME_RELEASE = ${UNAME_RELEASE}-UNAME_SYSTEM  = ${UNAME_SYSTEM}-UNAME_VERSION = ${UNAME_VERSION}-EOF--exit 1--# Local variables:-# eval: (add-hook 'write-file-hooks 'time-stamp)-# time-stamp-start: "timestamp='"-# time-stamp-format: "%:y-%02m-%02d"-# time-stamp-end: "'"-# End:
− config.sub 
@@ -1,1658 +0,0 @@-#! /bin/sh-# Configuration validation subroutine script.-#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,-#   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008-#   Free Software Foundation, Inc.--timestamp='2008-01-16'--# This file is (in principle) common to ALL GNU software.-# The presence of a machine in this file suggests that SOME GNU software-# can handle that machine.  It does not imply ALL GNU software can.-#-# This file is free software; you can redistribute it and/or modify-# it under the terms of the GNU General Public License as published by-# the Free Software Foundation; either version 2 of the License, or-# (at your option) any later version.-#-# This program is distributed in the hope that it will be useful,-# but WITHOUT ANY WARRANTY; without even the implied warranty of-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the-# GNU General Public License for more details.-#-# You should have received a copy of the GNU General Public License-# along with this program; if not, write to the Free Software-# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA-# 02110-1301, USA.-#-# As a special exception to the GNU General Public License, if you-# distribute this file as part of a program that contains a-# configuration script generated by Autoconf, you may include it under-# the same distribution terms that you use for the rest of that program.---# Please send patches to <config-patches@gnu.org>.  Submit a context-# diff and a properly formatted ChangeLog entry.-#-# Configuration subroutine to validate and canonicalize a configuration type.-# Supply the specified configuration type as an argument.-# If it is invalid, we print an error message on stderr and exit with code 1.-# Otherwise, we print the canonical config type on stdout and succeed.--# This file is supposed to be the same for all GNU packages-# and recognize all the CPU types, system types and aliases-# that are meaningful with *any* GNU software.-# Each package is responsible for reporting which valid configurations-# it does not support.  The user should be able to distinguish-# a failure to support a valid configuration from a meaningless-# configuration.--# The goal of this file is to map all the various variations of a given-# machine specification into a single specification in the form:-#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM-# or in some cases, the newer four-part form:-#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM-# It is wrong to echo any other type of specification.--me=`echo "$0" | sed -e 's,.*/,,'`--usage="\-Usage: $0 [OPTION] CPU-MFR-OPSYS-       $0 [OPTION] ALIAS--Canonicalize a configuration name.--Operation modes:-  -h, --help         print this help, then exit-  -t, --time-stamp   print date of last modification, then exit-  -v, --version      print version number, then exit--Report bugs and patches to <config-patches@gnu.org>."--version="\-GNU config.sub ($timestamp)--Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,-2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.--This is free software; see the source for copying conditions.  There is NO-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."--help="-Try \`$me --help' for more information."--# Parse command line-while test $# -gt 0 ; do-  case $1 in-    --time-stamp | --time* | -t )-       echo "$timestamp" ; exit ;;-    --version | -v )-       echo "$version" ; exit ;;-    --help | --h* | -h )-       echo "$usage"; exit ;;-    -- )     # Stop option processing-       shift; break ;;-    - )	# Use stdin as input.-       break ;;-    -* )-       echo "$me: invalid option $1$help"-       exit 1 ;;--    *local*)-       # First pass through any local machine types.-       echo $1-       exit ;;--    * )-       break ;;-  esac-done--case $# in- 0) echo "$me: missing argument$help" >&2-    exit 1;;- 1) ;;- *) echo "$me: too many arguments$help" >&2-    exit 1;;-esac--# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).-# Here we must recognize all the valid KERNEL-OS combinations.-maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`-case $maybe_os in-  nto-qnx* | linux-gnu* | linux-dietlibc | linux-newlib* | linux-uclibc* | \-  uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | \-  storm-chaos* | os2-emx* | rtmk-nova*)-    os=-$maybe_os-    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-    ;;-  *)-    basic_machine=`echo $1 | sed 's/-[^-]*$//'`-    if [ $basic_machine != $1 ]-    then os=`echo $1 | sed 's/.*-/-/'`-    else os=; fi-    ;;-esac--### Let's recognize common machines as not being operating systems so-### that things like config.sub decstation-3100 work.  We also-### recognize some manufacturers as not being operating systems, so we-### can provide default operating systems below.-case $os in-	-sun*os*)-		# Prevent following clause from handling this invalid input.-		;;-	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \-	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \-	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \-	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\-	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \-	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \-	-apple | -axis | -knuth | -cray)-		os=-		basic_machine=$1-		;;-	-sim | -cisco | -oki | -wec | -winbond)-		os=-		basic_machine=$1-		;;-	-scout)-		;;-	-wrs)-		os=-vxworks-		basic_machine=$1-		;;-	-chorusos*)-		os=-chorusos-		basic_machine=$1-		;;- 	-chorusrdb)- 		os=-chorusrdb-		basic_machine=$1- 		;;-	-hiux*)-		os=-hiuxwe2-		;;-	-sco6)-		os=-sco5v6-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`-		;;-	-sco5)-		os=-sco3.2v5-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`-		;;-	-sco4)-		os=-sco3.2v4-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`-		;;-	-sco3.2.[4-9]*)-		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`-		;;-	-sco3.2v[4-9]*)-		# Don't forget version if it is 3.2v4 or newer.-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`-		;;-	-sco5v6*)-		# Don't forget version if it is 3.2v4 or newer.-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`-		;;-	-sco*)-		os=-sco3.2v2-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`-		;;-	-udk*)-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`-		;;-	-isc)-		os=-isc2.2-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`-		;;-	-clix*)-		basic_machine=clipper-intergraph-		;;-	-isc*)-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`-		;;-	-lynx*)-		os=-lynxos-		;;-	-ptx*)-		basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`-		;;-	-windowsnt*)-		os=`echo $os | sed -e 's/windowsnt/winnt/'`-		;;-	-psos*)-		os=-psos-		;;-	-mint | -mint[0-9]*)-		basic_machine=m68k-atari-		os=-mint-		;;-esac--# Decode aliases for certain CPU-COMPANY combinations.-case $basic_machine in-	# Recognize the basic CPU types without company name.-	# Some are omitted here because they have special meanings below.-	1750a | 580 \-	| a29k \-	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \-	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \-	| am33_2.0 \-	| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \-	| bfin \-	| c4x | clipper \-	| d10v | d30v | dlx | dsp16xx \-	| fido | fr30 | frv \-	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \-	| i370 | i860 | i960 | ia64 \-	| ip2k | iq2000 \-	| m32c | m32r | m32rle | m68000 | m68k | m88k \-	| maxq | mb | microblaze | mcore | mep \-	| mips | mipsbe | mipseb | mipsel | mipsle \-	| mips16 \-	| mips64 | mips64el \-	| mips64vr | mips64vrel \-	| mips64orion | mips64orionel \-	| mips64vr4100 | mips64vr4100el \-	| mips64vr4300 | mips64vr4300el \-	| mips64vr5000 | mips64vr5000el \-	| mips64vr5900 | mips64vr5900el \-	| mipsisa32 | mipsisa32el \-	| mipsisa32r2 | mipsisa32r2el \-	| mipsisa64 | mipsisa64el \-	| mipsisa64r2 | mipsisa64r2el \-	| mipsisa64sb1 | mipsisa64sb1el \-	| mipsisa64sr71k | mipsisa64sr71kel \-	| mipstx39 | mipstx39el \-	| mn10200 | mn10300 \-	| mt \-	| msp430 \-	| nios | nios2 \-	| ns16k | ns32k \-	| or32 \-	| pdp10 | pdp11 | pj | pjl \-	| powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \-	| pyramid \-	| score \-	| sh | sh[1234] | sh[24]a | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \-	| sh64 | sh64le \-	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \-	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \-	| spu | strongarm \-	| tahoe | thumb | tic4x | tic80 | tron \-	| v850 | v850e \-	| we32k \-	| x86 | xc16x | xscale | xscalee[bl] | xstormy16 | xtensa \-	| z8k)-		basic_machine=$basic_machine-unknown-		;;-	m6811 | m68hc11 | m6812 | m68hc12)-		# Motorola 68HC11/12.-		basic_machine=$basic_machine-unknown-		os=-none-		;;-	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)-		;;-	ms1)-		basic_machine=mt-unknown-		;;--	# We use `pc' rather than `unknown'-	# because (1) that's what they normally are, and-	# (2) the word "unknown" tends to confuse beginning users.-	i*86 | x86_64)-	  basic_machine=$basic_machine-pc-	  ;;-	# Object if more than one company name word.-	*-*-*)-		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2-		exit 1-		;;-	# Recognize the basic CPU types with company name.-	580-* \-	| a29k-* \-	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \-	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \-	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* \-	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \-	| avr-* | avr32-* \-	| bfin-* | bs2000-* \-	| c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \-	| clipper-* | craynv-* | cydra-* \-	| d10v-* | d30v-* | dlx-* \-	| elxsi-* \-	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \-	| h8300-* | h8500-* \-	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \-	| i*86-* | i860-* | i960-* | ia64-* \-	| ip2k-* | iq2000-* \-	| m32c-* | m32r-* | m32rle-* \-	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \-	| m88110-* | m88k-* | maxq-* | mcore-* \-	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \-	| mips16-* \-	| mips64-* | mips64el-* \-	| mips64vr-* | mips64vrel-* \-	| mips64orion-* | mips64orionel-* \-	| mips64vr4100-* | mips64vr4100el-* \-	| mips64vr4300-* | mips64vr4300el-* \-	| mips64vr5000-* | mips64vr5000el-* \-	| mips64vr5900-* | mips64vr5900el-* \-	| mipsisa32-* | mipsisa32el-* \-	| mipsisa32r2-* | mipsisa32r2el-* \-	| mipsisa64-* | mipsisa64el-* \-	| mipsisa64r2-* | mipsisa64r2el-* \-	| mipsisa64sb1-* | mipsisa64sb1el-* \-	| mipsisa64sr71k-* | mipsisa64sr71kel-* \-	| mipstx39-* | mipstx39el-* \-	| mmix-* \-	| mt-* \-	| msp430-* \-	| nios-* | nios2-* \-	| none-* | np1-* | ns16k-* | ns32k-* \-	| orion-* \-	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \-	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \-	| pyramid-* \-	| romp-* | rs6000-* \-	| sh-* | sh[1234]-* | sh[24]a-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \-	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \-	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \-	| sparclite-* \-	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \-	| tahoe-* | thumb-* \-	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \-	| tron-* \-	| v850-* | v850e-* | vax-* \-	| we32k-* \-	| x86-* | x86_64-* | xc16x-* | xps100-* | xscale-* | xscalee[bl]-* \-	| xstormy16-* | xtensa*-* \-	| ymp-* \-	| z8k-*)-		;;-	# Recognize the basic CPU types without company name, with glob match.-	xtensa*)-		basic_machine=$basic_machine-unknown-		;;-	# Recognize the various machine names and aliases which stand-	# for a CPU type and a company and sometimes even an OS.-	386bsd)-		basic_machine=i386-unknown-		os=-bsd-		;;-	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)-		basic_machine=m68000-att-		;;-	3b*)-		basic_machine=we32k-att-		;;-	a29khif)-		basic_machine=a29k-amd-		os=-udi-		;;-    	abacus)-		basic_machine=abacus-unknown-		;;-	adobe68k)-		basic_machine=m68010-adobe-		os=-scout-		;;-	alliant | fx80)-		basic_machine=fx80-alliant-		;;-	altos | altos3068)-		basic_machine=m68k-altos-		;;-	am29k)-		basic_machine=a29k-none-		os=-bsd-		;;-	amd64)-		basic_machine=x86_64-pc-		;;-	amd64-*)-		basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`-		;;-	amdahl)-		basic_machine=580-amdahl-		os=-sysv-		;;-	amiga | amiga-*)-		basic_machine=m68k-unknown-		;;-	amigaos | amigados)-		basic_machine=m68k-unknown-		os=-amigaos-		;;-	amigaunix | amix)-		basic_machine=m68k-unknown-		os=-sysv4-		;;-	apollo68)-		basic_machine=m68k-apollo-		os=-sysv-		;;-	apollo68bsd)-		basic_machine=m68k-apollo-		os=-bsd-		;;-	aux)-		basic_machine=m68k-apple-		os=-aux-		;;-	balance)-		basic_machine=ns32k-sequent-		os=-dynix-		;;-	blackfin)-		basic_machine=bfin-unknown-		os=-linux-		;;-	blackfin-*)-		basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`-		os=-linux-		;;-	c90)-		basic_machine=c90-cray-		os=-unicos-		;;-	convex-c1)-		basic_machine=c1-convex-		os=-bsd-		;;-	convex-c2)-		basic_machine=c2-convex-		os=-bsd-		;;-	convex-c32)-		basic_machine=c32-convex-		os=-bsd-		;;-	convex-c34)-		basic_machine=c34-convex-		os=-bsd-		;;-	convex-c38)-		basic_machine=c38-convex-		os=-bsd-		;;-	cray | j90)-		basic_machine=j90-cray-		os=-unicos-		;;-	craynv)-		basic_machine=craynv-cray-		os=-unicosmp-		;;-	cr16)-		basic_machine=cr16-unknown-		os=-elf-		;;-	crds | unos)-		basic_machine=m68k-crds-		;;-	crisv32 | crisv32-* | etraxfs*)-		basic_machine=crisv32-axis-		;;-	cris | cris-* | etrax*)-		basic_machine=cris-axis-		;;-	crx)-		basic_machine=crx-unknown-		os=-elf-		;;-	da30 | da30-*)-		basic_machine=m68k-da30-		;;-	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)-		basic_machine=mips-dec-		;;-	decsystem10* | dec10*)-		basic_machine=pdp10-dec-		os=-tops10-		;;-	decsystem20* | dec20*)-		basic_machine=pdp10-dec-		os=-tops20-		;;-	delta | 3300 | motorola-3300 | motorola-delta \-	      | 3300-motorola | delta-motorola)-		basic_machine=m68k-motorola-		;;-	delta88)-		basic_machine=m88k-motorola-		os=-sysv3-		;;-	djgpp)-		basic_machine=i586-pc-		os=-msdosdjgpp-		;;-	dpx20 | dpx20-*)-		basic_machine=rs6000-bull-		os=-bosx-		;;-	dpx2* | dpx2*-bull)-		basic_machine=m68k-bull-		os=-sysv3-		;;-	ebmon29k)-		basic_machine=a29k-amd-		os=-ebmon-		;;-	elxsi)-		basic_machine=elxsi-elxsi-		os=-bsd-		;;-	encore | umax | mmax)-		basic_machine=ns32k-encore-		;;-	es1800 | OSE68k | ose68k | ose | OSE)-		basic_machine=m68k-ericsson-		os=-ose-		;;-	fx2800)-		basic_machine=i860-alliant-		;;-	genix)-		basic_machine=ns32k-ns-		;;-	gmicro)-		basic_machine=tron-gmicro-		os=-sysv-		;;-	go32)-		basic_machine=i386-pc-		os=-go32-		;;-	h3050r* | hiux*)-		basic_machine=hppa1.1-hitachi-		os=-hiuxwe2-		;;-	h8300hms)-		basic_machine=h8300-hitachi-		os=-hms-		;;-	h8300xray)-		basic_machine=h8300-hitachi-		os=-xray-		;;-	h8500hms)-		basic_machine=h8500-hitachi-		os=-hms-		;;-	harris)-		basic_machine=m88k-harris-		os=-sysv3-		;;-	hp300-*)-		basic_machine=m68k-hp-		;;-	hp300bsd)-		basic_machine=m68k-hp-		os=-bsd-		;;-	hp300hpux)-		basic_machine=m68k-hp-		os=-hpux-		;;-	hp3k9[0-9][0-9] | hp9[0-9][0-9])-		basic_machine=hppa1.0-hp-		;;-	hp9k2[0-9][0-9] | hp9k31[0-9])-		basic_machine=m68000-hp-		;;-	hp9k3[2-9][0-9])-		basic_machine=m68k-hp-		;;-	hp9k6[0-9][0-9] | hp6[0-9][0-9])-		basic_machine=hppa1.0-hp-		;;-	hp9k7[0-79][0-9] | hp7[0-79][0-9])-		basic_machine=hppa1.1-hp-		;;-	hp9k78[0-9] | hp78[0-9])-		# FIXME: really hppa2.0-hp-		basic_machine=hppa1.1-hp-		;;-	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)-		# FIXME: really hppa2.0-hp-		basic_machine=hppa1.1-hp-		;;-	hp9k8[0-9][13679] | hp8[0-9][13679])-		basic_machine=hppa1.1-hp-		;;-	hp9k8[0-9][0-9] | hp8[0-9][0-9])-		basic_machine=hppa1.0-hp-		;;-	hppa-next)-		os=-nextstep3-		;;-	hppaosf)-		basic_machine=hppa1.1-hp-		os=-osf-		;;-	hppro)-		basic_machine=hppa1.1-hp-		os=-proelf-		;;-	i370-ibm* | ibm*)-		basic_machine=i370-ibm-		;;-# I'm not sure what "Sysv32" means.  Should this be sysv3.2?-	i*86v32)-		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`-		os=-sysv32-		;;-	i*86v4*)-		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`-		os=-sysv4-		;;-	i*86v)-		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`-		os=-sysv-		;;-	i*86sol2)-		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`-		os=-solaris2-		;;-	i386mach)-		basic_machine=i386-mach-		os=-mach-		;;-	i386-vsta | vsta)-		basic_machine=i386-unknown-		os=-vsta-		;;-	iris | iris4d)-		basic_machine=mips-sgi-		case $os in-		    -irix*)-			;;-		    *)-			os=-irix4-			;;-		esac-		;;-	isi68 | isi)-		basic_machine=m68k-isi-		os=-sysv-		;;-	m68knommu)-		basic_machine=m68k-unknown-		os=-linux-		;;-	m68knommu-*)-		basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`-		os=-linux-		;;-	m88k-omron*)-		basic_machine=m88k-omron-		;;-	magnum | m3230)-		basic_machine=mips-mips-		os=-sysv-		;;-	merlin)-		basic_machine=ns32k-utek-		os=-sysv-		;;-	mingw32)-		basic_machine=i386-pc-		os=-mingw32-		;;-	mingw32ce)-		basic_machine=arm-unknown-		os=-mingw32ce-		;;-	miniframe)-		basic_machine=m68000-convergent-		;;-	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)-		basic_machine=m68k-atari-		os=-mint-		;;-	mips3*-*)-		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-		;;-	mips3*)-		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown-		;;-	monitor)-		basic_machine=m68k-rom68k-		os=-coff-		;;-	morphos)-		basic_machine=powerpc-unknown-		os=-morphos-		;;-	msdos)-		basic_machine=i386-pc-		os=-msdos-		;;-	ms1-*)-		basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`-		;;-	mvs)-		basic_machine=i370-ibm-		os=-mvs-		;;-	ncr3000)-		basic_machine=i486-ncr-		os=-sysv4-		;;-	netbsd386)-		basic_machine=i386-unknown-		os=-netbsd-		;;-	netwinder)-		basic_machine=armv4l-rebel-		os=-linux-		;;-	news | news700 | news800 | news900)-		basic_machine=m68k-sony-		os=-newsos-		;;-	news1000)-		basic_machine=m68030-sony-		os=-newsos-		;;-	news-3600 | risc-news)-		basic_machine=mips-sony-		os=-newsos-		;;-	necv70)-		basic_machine=v70-nec-		os=-sysv-		;;-	next | m*-next )-		basic_machine=m68k-next-		case $os in-		    -nextstep* )-			;;-		    -ns2*)-		      os=-nextstep2-			;;-		    *)-		      os=-nextstep3-			;;-		esac-		;;-	nh3000)-		basic_machine=m68k-harris-		os=-cxux-		;;-	nh[45]000)-		basic_machine=m88k-harris-		os=-cxux-		;;-	nindy960)-		basic_machine=i960-intel-		os=-nindy-		;;-	mon960)-		basic_machine=i960-intel-		os=-mon960-		;;-	nonstopux)-		basic_machine=mips-compaq-		os=-nonstopux-		;;-	np1)-		basic_machine=np1-gould-		;;-	nsr-tandem)-		basic_machine=nsr-tandem-		;;-	op50n-* | op60c-*)-		basic_machine=hppa1.1-oki-		os=-proelf-		;;-	openrisc | openrisc-*)-		basic_machine=or32-unknown-		;;-	os400)-		basic_machine=powerpc-ibm-		os=-os400-		;;-	OSE68000 | ose68000)-		basic_machine=m68000-ericsson-		os=-ose-		;;-	os68k)-		basic_machine=m68k-none-		os=-os68k-		;;-	pa-hitachi)-		basic_machine=hppa1.1-hitachi-		os=-hiuxwe2-		;;-	paragon)-		basic_machine=i860-intel-		os=-osf-		;;-	parisc)-		basic_machine=hppa-unknown-		os=-linux-		;;-	parisc-*)-		basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'`-		os=-linux-		;;-	pbd)-		basic_machine=sparc-tti-		;;-	pbb)-		basic_machine=m68k-tti-		;;-	pc532 | pc532-*)-		basic_machine=ns32k-pc532-		;;-	pc98)-		basic_machine=i386-pc-		;;-	pc98-*)-		basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`-		;;-	pentium | p5 | k5 | k6 | nexgen | viac3)-		basic_machine=i586-pc-		;;-	pentiumpro | p6 | 6x86 | athlon | athlon_*)-		basic_machine=i686-pc-		;;-	pentiumii | pentium2 | pentiumiii | pentium3)-		basic_machine=i686-pc-		;;-	pentium4)-		basic_machine=i786-pc-		;;-	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)-		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`-		;;-	pentiumpro-* | p6-* | 6x86-* | athlon-*)-		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`-		;;-	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)-		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`-		;;-	pentium4-*)-		basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`-		;;-	pn)-		basic_machine=pn-gould-		;;-	power)	basic_machine=power-ibm-		;;-	ppc)	basic_machine=powerpc-unknown-		;;-	ppc-*)	basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`-		;;-	ppcle | powerpclittle | ppc-le | powerpc-little)-		basic_machine=powerpcle-unknown-		;;-	ppcle-* | powerpclittle-*)-		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`-		;;-	ppc64)	basic_machine=powerpc64-unknown-		;;-	ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`-		;;-	ppc64le | powerpc64little | ppc64-le | powerpc64-little)-		basic_machine=powerpc64le-unknown-		;;-	ppc64le-* | powerpc64little-*)-		basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`-		;;-	ps2)-		basic_machine=i386-ibm-		;;-	pw32)-		basic_machine=i586-unknown-		os=-pw32-		;;-	rdos)-		basic_machine=i386-pc-		os=-rdos-		;;-	rom68k)-		basic_machine=m68k-rom68k-		os=-coff-		;;-	rm[46]00)-		basic_machine=mips-siemens-		;;-	rtpc | rtpc-*)-		basic_machine=romp-ibm-		;;-	s390 | s390-*)-		basic_machine=s390-ibm-		;;-	s390x | s390x-*)-		basic_machine=s390x-ibm-		;;-	sa29200)-		basic_machine=a29k-amd-		os=-udi-		;;-	sb1)-		basic_machine=mipsisa64sb1-unknown-		;;-	sb1el)-		basic_machine=mipsisa64sb1el-unknown-		;;-	sde)-		basic_machine=mipsisa32-sde-		os=-elf-		;;-	sei)-		basic_machine=mips-sei-		os=-seiux-		;;-	sequent)-		basic_machine=i386-sequent-		;;-	sh)-		basic_machine=sh-hitachi-		os=-hms-		;;-	sh5el)-		basic_machine=sh5le-unknown-		;;-	sh64)-		basic_machine=sh64-unknown-		;;-	sparclite-wrs | simso-wrs)-		basic_machine=sparclite-wrs-		os=-vxworks-		;;-	sps7)-		basic_machine=m68k-bull-		os=-sysv2-		;;-	spur)-		basic_machine=spur-unknown-		;;-	st2000)-		basic_machine=m68k-tandem-		;;-	stratus)-		basic_machine=i860-stratus-		os=-sysv4-		;;-	sun2)-		basic_machine=m68000-sun-		;;-	sun2os3)-		basic_machine=m68000-sun-		os=-sunos3-		;;-	sun2os4)-		basic_machine=m68000-sun-		os=-sunos4-		;;-	sun3os3)-		basic_machine=m68k-sun-		os=-sunos3-		;;-	sun3os4)-		basic_machine=m68k-sun-		os=-sunos4-		;;-	sun4os3)-		basic_machine=sparc-sun-		os=-sunos3-		;;-	sun4os4)-		basic_machine=sparc-sun-		os=-sunos4-		;;-	sun4sol2)-		basic_machine=sparc-sun-		os=-solaris2-		;;-	sun3 | sun3-*)-		basic_machine=m68k-sun-		;;-	sun4)-		basic_machine=sparc-sun-		;;-	sun386 | sun386i | roadrunner)-		basic_machine=i386-sun-		;;-	sv1)-		basic_machine=sv1-cray-		os=-unicos-		;;-	symmetry)-		basic_machine=i386-sequent-		os=-dynix-		;;-	t3e)-		basic_machine=alphaev5-cray-		os=-unicos-		;;-	t90)-		basic_machine=t90-cray-		os=-unicos-		;;-	tic54x | c54x*)-		basic_machine=tic54x-unknown-		os=-coff-		;;-	tic55x | c55x*)-		basic_machine=tic55x-unknown-		os=-coff-		;;-	tic6x | c6x*)-		basic_machine=tic6x-unknown-		os=-coff-		;;-	tile*)-		basic_machine=tile-unknown-		os=-linux-gnu-		;;-	tx39)-		basic_machine=mipstx39-unknown-		;;-	tx39el)-		basic_machine=mipstx39el-unknown-		;;-	toad1)-		basic_machine=pdp10-xkl-		os=-tops20-		;;-	tower | tower-32)-		basic_machine=m68k-ncr-		;;-	tpf)-		basic_machine=s390x-ibm-		os=-tpf-		;;-	udi29k)-		basic_machine=a29k-amd-		os=-udi-		;;-	ultra3)-		basic_machine=a29k-nyu-		os=-sym1-		;;-	v810 | necv810)-		basic_machine=v810-nec-		os=-none-		;;-	vaxv)-		basic_machine=vax-dec-		os=-sysv-		;;-	vms)-		basic_machine=vax-dec-		os=-vms-		;;-	vpp*|vx|vx-*)-		basic_machine=f301-fujitsu-		;;-	vxworks960)-		basic_machine=i960-wrs-		os=-vxworks-		;;-	vxworks68)-		basic_machine=m68k-wrs-		os=-vxworks-		;;-	vxworks29k)-		basic_machine=a29k-wrs-		os=-vxworks-		;;-	w65*)-		basic_machine=w65-wdc-		os=-none-		;;-	w89k-*)-		basic_machine=hppa1.1-winbond-		os=-proelf-		;;-	xbox)-		basic_machine=i686-pc-		os=-mingw32-		;;-	xps | xps100)-		basic_machine=xps100-honeywell-		;;-	ymp)-		basic_machine=ymp-cray-		os=-unicos-		;;-	z8k-*-coff)-		basic_machine=z8k-unknown-		os=-sim-		;;-	none)-		basic_machine=none-none-		os=-none-		;;--# Here we handle the default manufacturer of certain CPU types.  It is in-# some cases the only manufacturer, in others, it is the most popular.-	w89k)-		basic_machine=hppa1.1-winbond-		;;-	op50n)-		basic_machine=hppa1.1-oki-		;;-	op60c)-		basic_machine=hppa1.1-oki-		;;-	romp)-		basic_machine=romp-ibm-		;;-	mmix)-		basic_machine=mmix-knuth-		;;-	rs6000)-		basic_machine=rs6000-ibm-		;;-	vax)-		basic_machine=vax-dec-		;;-	pdp10)-		# there are many clones, so DEC is not a safe bet-		basic_machine=pdp10-unknown-		;;-	pdp11)-		basic_machine=pdp11-dec-		;;-	we32k)-		basic_machine=we32k-att-		;;-	sh[1234] | sh[24]a | sh[34]eb | sh[1234]le | sh[23]ele)-		basic_machine=sh-unknown-		;;-	sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)-		basic_machine=sparc-sun-		;;-	cydra)-		basic_machine=cydra-cydrome-		;;-	orion)-		basic_machine=orion-highlevel-		;;-	orion105)-		basic_machine=clipper-highlevel-		;;-	mac | mpw | mac-mpw)-		basic_machine=m68k-apple-		;;-	pmac | pmac-mpw)-		basic_machine=powerpc-apple-		;;-	*-unknown)-		# Make sure to match an already-canonicalized machine name.-		;;-	*)-		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2-		exit 1-		;;-esac--# Here we canonicalize certain aliases for manufacturers.-case $basic_machine in-	*-digital*)-		basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`-		;;-	*-commodore*)-		basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`-		;;-	*)-		;;-esac--# Decode manufacturer-specific aliases for certain operating systems.--if [ x"$os" != x"" ]-then-case $os in-        # First match some system type aliases-        # that might get confused with valid system types.-	# -solaris* is a basic system type, with this one exception.-	-solaris1 | -solaris1.*)-		os=`echo $os | sed -e 's|solaris1|sunos4|'`-		;;-	-solaris)-		os=-solaris2-		;;-	-svr4*)-		os=-sysv4-		;;-	-unixware*)-		os=-sysv4.2uw-		;;-	-gnu/linux*)-		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`-		;;-	# First accept the basic system types.-	# The portable systems comes first.-	# Each alternative MUST END IN A *, to match a version number.-	# -sysv* is not here because it comes later, after sysvr4.-	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \-	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\-	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \-	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \-	      | -aos* \-	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \-	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \-	      | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \-	      | -openbsd* | -solidbsd* \-	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \-	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \-	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \-	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \-	      | -chorusos* | -chorusrdb* \-	      | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \-	      | -mingw32* | -linux-gnu* | -linux-newlib* | -linux-uclibc* \-	      | -uxpv* | -beos* | -mpeix* | -udk* \-	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \-	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \-	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \-	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \-	      | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \-	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \-	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops*)-	# Remember, each alternative MUST END IN *, to match a version number.-		;;-	-qnx*)-		case $basic_machine in-		    x86-* | i*86-*)-			;;-		    *)-			os=-nto$os-			;;-		esac-		;;-	-nto-qnx*)-		;;-	-nto*)-		os=`echo $os | sed -e 's|nto|nto-qnx|'`-		;;-	-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \-	      | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \-	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)-		;;-	-mac*)-		os=`echo $os | sed -e 's|mac|macos|'`-		;;-	-linux-dietlibc)-		os=-linux-dietlibc-		;;-	-linux*)-		os=`echo $os | sed -e 's|linux|linux-gnu|'`-		;;-	-sunos5*)-		os=`echo $os | sed -e 's|sunos5|solaris2|'`-		;;-	-sunos6*)-		os=`echo $os | sed -e 's|sunos6|solaris3|'`-		;;-	-opened*)-		os=-openedition-		;;-        -os400*)-		os=-os400-		;;-	-wince*)-		os=-wince-		;;-	-osfrose*)-		os=-osfrose-		;;-	-osf*)-		os=-osf-		;;-	-utek*)-		os=-bsd-		;;-	-dynix*)-		os=-bsd-		;;-	-acis*)-		os=-aos-		;;-	-atheos*)-		os=-atheos-		;;-	-syllable*)-		os=-syllable-		;;-	-386bsd)-		os=-bsd-		;;-	-ctix* | -uts*)-		os=-sysv-		;;-	-nova*)-		os=-rtmk-nova-		;;-	-ns2 )-		os=-nextstep2-		;;-	-nsk*)-		os=-nsk-		;;-	# Preserve the version number of sinix5.-	-sinix5.*)-		os=`echo $os | sed -e 's|sinix|sysv|'`-		;;-	-sinix*)-		os=-sysv4-		;;-        -tpf*)-		os=-tpf-		;;-	-triton*)-		os=-sysv3-		;;-	-oss*)-		os=-sysv3-		;;-	-svr4)-		os=-sysv4-		;;-	-svr3)-		os=-sysv3-		;;-	-sysvr4)-		os=-sysv4-		;;-	# This must come after -sysvr4.-	-sysv*)-		;;-	-ose*)-		os=-ose-		;;-	-es1800*)-		os=-ose-		;;-	-xenix)-		os=-xenix-		;;-	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)-		os=-mint-		;;-	-aros*)-		os=-aros-		;;-	-kaos*)-		os=-kaos-		;;-	-zvmoe)-		os=-zvmoe-		;;-	-none)-		;;-	*)-		# Get rid of the `-' at the beginning of $os.-		os=`echo $os | sed 's/[^-]*-//'`-		echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2-		exit 1-		;;-esac-else--# Here we handle the default operating systems that come with various machines.-# The value should be what the vendor currently ships out the door with their-# machine or put another way, the most popular os provided with the machine.--# Note that if you're going to try to match "-MANUFACTURER" here (say,-# "-sun"), then you have to tell the case statement up towards the top-# that MANUFACTURER isn't an operating system.  Otherwise, code above-# will signal an error saying that MANUFACTURER isn't an operating-# system, and we'll never get to this point.--case $basic_machine in-        score-*)-		os=-elf-		;;-        spu-*)-		os=-elf-		;;-	*-acorn)-		os=-riscix1.2-		;;-	arm*-rebel)-		os=-linux-		;;-	arm*-semi)-		os=-aout-		;;-        c4x-* | tic4x-*)-        	os=-coff-		;;-	# This must come before the *-dec entry.-	pdp10-*)-		os=-tops20-		;;-	pdp11-*)-		os=-none-		;;-	*-dec | vax-*)-		os=-ultrix4.2-		;;-	m68*-apollo)-		os=-domain-		;;-	i386-sun)-		os=-sunos4.0.2-		;;-	m68000-sun)-		os=-sunos3-		# This also exists in the configure program, but was not the-		# default.-		# os=-sunos4-		;;-	m68*-cisco)-		os=-aout-		;;-        mep-*)-		os=-elf-		;;-	mips*-cisco)-		os=-elf-		;;-	mips*-*)-		os=-elf-		;;-	or32-*)-		os=-coff-		;;-	*-tti)	# must be before sparc entry or we get the wrong os.-		os=-sysv3-		;;-	sparc-* | *-sun)-		os=-sunos4.1.1-		;;-	*-be)-		os=-beos-		;;-	*-haiku)-		os=-haiku-		;;-	*-ibm)-		os=-aix-		;;-    	*-knuth)-		os=-mmixware-		;;-	*-wec)-		os=-proelf-		;;-	*-winbond)-		os=-proelf-		;;-	*-oki)-		os=-proelf-		;;-	*-hp)-		os=-hpux-		;;-	*-hitachi)-		os=-hiux-		;;-	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)-		os=-sysv-		;;-	*-cbm)-		os=-amigaos-		;;-	*-dg)-		os=-dgux-		;;-	*-dolphin)-		os=-sysv3-		;;-	m68k-ccur)-		os=-rtu-		;;-	m88k-omron*)-		os=-luna-		;;-	*-next )-		os=-nextstep-		;;-	*-sequent)-		os=-ptx-		;;-	*-crds)-		os=-unos-		;;-	*-ns)-		os=-genix-		;;-	i370-*)-		os=-mvs-		;;-	*-next)-		os=-nextstep3-		;;-	*-gould)-		os=-sysv-		;;-	*-highlevel)-		os=-bsd-		;;-	*-encore)-		os=-bsd-		;;-	*-sgi)-		os=-irix-		;;-	*-siemens)-		os=-sysv4-		;;-	*-masscomp)-		os=-rtu-		;;-	f30[01]-fujitsu | f700-fujitsu)-		os=-uxpv-		;;-	*-rom68k)-		os=-coff-		;;-	*-*bug)-		os=-coff-		;;-	*-apple)-		os=-macos-		;;-	*-atari*)-		os=-mint-		;;-	*)-		os=-none-		;;-esac-fi--# Here we handle the case where we know the os, and the CPU type, but not the-# manufacturer.  We pick the logical manufacturer.-vendor=unknown-case $basic_machine in-	*-unknown)-		case $os in-			-riscix*)-				vendor=acorn-				;;-			-sunos*)-				vendor=sun-				;;-			-aix*)-				vendor=ibm-				;;-			-beos*)-				vendor=be-				;;-			-hpux*)-				vendor=hp-				;;-			-mpeix*)-				vendor=hp-				;;-			-hiux*)-				vendor=hitachi-				;;-			-unos*)-				vendor=crds-				;;-			-dgux*)-				vendor=dg-				;;-			-luna*)-				vendor=omron-				;;-			-genix*)-				vendor=ns-				;;-			-mvs* | -opened*)-				vendor=ibm-				;;-			-os400*)-				vendor=ibm-				;;-			-ptx*)-				vendor=sequent-				;;-			-tpf*)-				vendor=ibm-				;;-			-vxsim* | -vxworks* | -windiss*)-				vendor=wrs-				;;-			-aux*)-				vendor=apple-				;;-			-hms*)-				vendor=hitachi-				;;-			-mpw* | -macos*)-				vendor=apple-				;;-			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)-				vendor=atari-				;;-			-vos*)-				vendor=stratus-				;;-		esac-		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`-		;;-esac--echo $basic_machine$os-exit--# Local variables:-# eval: (add-hook 'write-file-hooks 'time-stamp)-# time-stamp-start: "timestamp='"-# time-stamp-format: "%:y-%02m-%02d"-# time-stamp-end: "'"-# End:
− configure 
@@ -1,4789 +0,0 @@-#! /bin/sh-# Guess values for system-dependent variables and create Makefiles.-# Generated by GNU Autoconf 2.69 for Haskell CUDA BLAS bindings 0.1.0.0.-#-# Report bugs to <tmcdonell@cse.unsw.edu.au>.-#-#-# Copyright (C) 1992-1996, 1998-2012 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 more Bourne compatible-DUALCASE=1; export DUALCASE # for MKS sh-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :-  emulate sh-  NULLCMD=:-  # Pre-4.2 versions of Zsh do 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---as_nl='-'-export as_nl-# Printing a long string crashes Solaris 7 /usr/bin/printf.-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo-# Prefer a ksh shell builtin over an external printf program on Solaris,-# but without wasting forks for bash or zsh.-if test -z "$BASH_VERSION$ZSH_VERSION" \-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then-  as_echo='print -r --'-  as_echo_n='print -rn --'-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then-  as_echo='printf %s\n'-  as_echo_n='printf %s'-else-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'-    as_echo_n='/usr/ucb/echo -n'-  else-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'-    as_echo_n_body='eval-      arg=$1;-      case $arg in #(-      *"$as_nl"*)-	expr "X$arg" : "X\\(.*\\)$as_nl";-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;-      esac;-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"-    '-    export as_echo_n_body-    as_echo_n='sh -c $as_echo_n_body as_echo'-  fi-  export as_echo_body-  as_echo='sh -c $as_echo_body as_echo'-fi--# The user is always right.-if test "${PATH_SEPARATOR+set}" != set; then-  PATH_SEPARATOR=:-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||-      PATH_SEPARATOR=';'-  }-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.)-IFS=" ""	$as_nl"--# Find who we are.  Look in the path if we contain no directory separator.-as_myself=-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-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2-  exit 1-fi--# Unset variables that we do not need and which cause bugs (e.g. in-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"-# suppresses any "Segmentation fault" message there.  '((' could-# trigger a bug in pdksh 5.2.14.-for as_var in BASH_ENV ENV MAIL MAILPATH-do eval test x\${$as_var+set} = xset \-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :-done-PS1='$ '-PS2='> '-PS4='+ '--# NLS nuisances.-LC_ALL=C-export LC_ALL-LANGUAGE=C-export LANGUAGE--# CDPATH.-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH--# Use a proper internal environment variable to ensure we don't fall-  # into an infinite loop, continuously re-executing ourselves.-  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then-    _as_can_reexec=no; export _as_can_reexec;-    # We cannot yet assume a decent shell, so we have to provide a-# neutralization value for shells without unset; and this also-# works around shells that cannot unset nonexistent variables.-# Preserve -v and -x to the replacement shell.-BASH_ENV=/dev/null-ENV=/dev/null-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV-case $- in # ((((-  *v*x* | *x*v* ) as_opts=-vx ;;-  *v* ) as_opts=-v ;;-  *x* ) as_opts=-x ;;-  * ) as_opts= ;;-esac-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}-# Admittedly, this is quite paranoid, since all the known shells bail-# out after a failed `exec'.-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2-as_fn_exit 255-  fi-  # We don't want this to propagate to other subprocesses.-          { _as_can_reexec=; unset _as_can_reexec;}-if test "x$CONFIG_SHELL" = x; then-  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :-  emulate sh-  NULLCMD=:-  # Pre-4.2 versions of Zsh do 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-"-  as_required="as_fn_return () { (exit \$1); }-as_fn_success () { as_fn_return 0; }-as_fn_failure () { as_fn_return 1; }-as_fn_ret_success () { return 0; }-as_fn_ret_failure () { return 1; }--exitcode=0-as_fn_success || { exitcode=1; echo as_fn_success failed.; }-as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }-as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }-as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }-if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :--else-  exitcode=1; echo positional parameters were not saved.-fi-test x\$exitcode = x0 || exit 1-test -x / || exit 1"-  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO-  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO-  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&-  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1-test \$(( 1 + 1 )) = 2 || exit 1"-  if (eval "$as_required") 2>/dev/null; then :-  as_have_required=yes-else-  as_have_required=no-fi-  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :--else-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR-as_found=false-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH-do-  IFS=$as_save_IFS-  test -z "$as_dir" && as_dir=.-  as_found=:-  case $as_dir in #(-	 /*)-	   for as_base in sh bash ksh sh5; do-	     # Try only shells that exist, to save several forks.-	     as_shell=$as_dir/$as_base-	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&-		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :-  CONFIG_SHELL=$as_shell as_have_required=yes-		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :-  break 2-fi-fi-	   done;;-       esac-  as_found=false-done-$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&-	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :-  CONFIG_SHELL=$SHELL as_have_required=yes-fi; }-IFS=$as_save_IFS---      if test "x$CONFIG_SHELL" != x; then :-  export CONFIG_SHELL-             # We cannot yet assume a decent shell, so we have to provide a-# neutralization value for shells without unset; and this also-# works around shells that cannot unset nonexistent variables.-# Preserve -v and -x to the replacement shell.-BASH_ENV=/dev/null-ENV=/dev/null-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV-case $- in # ((((-  *v*x* | *x*v* ) as_opts=-vx ;;-  *v* ) as_opts=-v ;;-  *x* ) as_opts=-x ;;-  * ) as_opts= ;;-esac-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}-# Admittedly, this is quite paranoid, since all the known shells bail-# out after a failed `exec'.-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2-exit 255-fi--    if test x$as_have_required = xno; then :-  $as_echo "$0: This script requires a shell more modern than all"-  $as_echo "$0: the shells that I found on your system."-  if test x${ZSH_VERSION+set} = xset ; then-    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"-    $as_echo "$0: be upgraded to zsh 4.3.4 or later."-  else-    $as_echo "$0: Please tell bug-autoconf@gnu.org and-$0: tmcdonell@cse.unsw.edu.au about your system, including-$0: any error possibly output before this message. Then-$0: install a modern shell, or manually run the script-$0: under such a shell if you do have one."-  fi-  exit 1-fi-fi-fi-SHELL=${CONFIG_SHELL-/bin/sh}-export SHELL-# Unset more variables known to interfere with behavior of common tools.-CLICOLOR_FORCE= GREP_OPTIONS=-unset CLICOLOR_FORCE GREP_OPTIONS--## --------------------- ##-## M4sh Shell Functions. ##-## --------------------- ##-# as_fn_unset VAR-# ----------------# Portably unset VAR.-as_fn_unset ()-{-  { eval $1=; unset $1;}-}-as_unset=as_fn_unset--# as_fn_set_status STATUS-# ------------------------# Set $? to STATUS, without forking.-as_fn_set_status ()-{-  return $1-} # as_fn_set_status--# as_fn_exit STATUS-# ------------------# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.-as_fn_exit ()-{-  set +e-  as_fn_set_status $1-  exit $1-} # as_fn_exit--# as_fn_mkdir_p-# --------------# Create "$as_dir" as a directory, including parents if necessary.-as_fn_mkdir_p ()-{--  case $as_dir in #(-  -*) as_dir=./$as_dir;;-  esac-  test -d "$as_dir" || eval $as_mkdir_p || {-    as_dirs=-    while :; do-      case $as_dir in #(-      *\'*) as_qdir=`$as_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 ||-$as_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" || as_fn_error $? "cannot create directory $as_dir"---} # as_fn_mkdir_p--# as_fn_executable_p FILE-# ------------------------# Test if FILE is an executable regular file.-as_fn_executable_p ()-{-  test -f "$1" && test -x "$1"-} # as_fn_executable_p-# as_fn_append VAR VALUE-# -----------------------# Append the text in VALUE to the end of the definition contained in VAR. Take-# advantage of any shell optimizations that allow amortized linear growth over-# repeated appends, instead of the typical quadratic growth present in naive-# implementations.-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :-  eval 'as_fn_append ()-  {-    eval $1+=\$2-  }'-else-  as_fn_append ()-  {-    eval $1=\$$1\$2-  }-fi # as_fn_append--# as_fn_arith ARG...-# -------------------# Perform arithmetic evaluation on the ARGs, and store the result in the-# global $as_val. Take advantage of shells that can avoid forks. The arguments-# must be portable across $(()) and expr.-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :-  eval 'as_fn_arith ()-  {-    as_val=$(( $* ))-  }'-else-  as_fn_arith ()-  {-    as_val=`expr "$@" || test $? -eq 1`-  }-fi # as_fn_arith---# as_fn_error STATUS ERROR [LINENO LOG_FD]-# -----------------------------------------# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the-# script with STATUS, using 1 if that was 0.-as_fn_error ()-{-  as_status=$1; test $as_status -eq 0 && as_status=1-  if test "$4"; then-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4-  fi-  $as_echo "$as_me: error: $2" >&2-  as_fn_exit $as_status-} # as_fn_error--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--if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then-  as_dirname=dirname-else-  as_dirname=false-fi--as_me=`$as_basename -- "$0" ||-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \-	 X"$0" : 'X\(//\)$' \| \-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||-$as_echo X/"$0" |-    sed '/^.*\/\([^/][^/]*\)\/*$/{-	    s//\1/-	    q-	  }-	  /^X\/\(\/\/\)$/{-	    s//\1/-	    q-	  }-	  /^X\/\(\/\).*/{-	    s//\1/-	    q-	  }-	  s/.*/./; q'`--# 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---  as_lineno_1=$LINENO as_lineno_1a=$LINENO-  as_lineno_2=$LINENO as_lineno_2a=$LINENO-  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&-  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {-  # 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" ||-    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }--  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have-  # already done that, so ensure we don't try to do so again and fall-  # in an infinite loop.  This has already happened in practice.-  _as_can_reexec=no; export _as_can_reexec-  # 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-}--ECHO_C= ECHO_N= ECHO_T=-case `echo -n x` in #(((((--n*)-  case `echo 'xy\c'` in-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.-  xy)  ECHO_C='\c';;-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null-       ECHO_T='	';;-  esac;;-*)-  ECHO_N='-n';;-esac--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 2>/dev/null-fi-if (echo >conf$$.file) 2>/dev/null; then-  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 -pR'.-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||-      as_ln_s='cp -pR'-  elif ln conf$$.file conf$$ 2>/dev/null; then-    as_ln_s=ln-  else-    as_ln_s='cp -pR'-  fi-else-  as_ln_s='cp -pR'-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='mkdir -p "$as_dir"'-else-  test -d ./-p && rmdir ./-p-  as_mkdir_p=false-fi--as_test_x='test -x'-as_executable_p=as_fn_executable_p--# 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'"---test -n "$DJDIR" || exec 7<&0 </dev/null-exec 6>&1--# Name of the host.-# hostname on some systems (SVR3.2, old GNU/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=--# Identity of this package.-PACKAGE_NAME='Haskell CUDA BLAS bindings'-PACKAGE_TARNAME='cublas'-PACKAGE_VERSION='0.1.0.0'-PACKAGE_STRING='Haskell CUDA BLAS bindings 0.1.0.0'-PACKAGE_BUGREPORT='tmcdonell@cse.unsw.edu.au'-PACKAGE_URL=''--ac_unique_file="Foreign/CUDA/Cublas.hs"-# Factoring default headers for most tests.-ac_includes_default="\-#include <stdio.h>-#ifdef HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif-#ifdef HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif-#ifdef STDC_HEADERS-# include <stdlib.h>-# include <stddef.h>-#else-# ifdef HAVE_STDLIB_H-#  include <stdlib.h>-# endif-#endif-#ifdef HAVE_STRING_H-# if !defined STDC_HEADERS && defined HAVE_MEMORY_H-#  include <memory.h>-# endif-# include <string.h>-#endif-#ifdef HAVE_STRINGS_H-# include <strings.h>-#endif-#ifdef HAVE_INTTYPES_H-# include <inttypes.h>-#endif-#ifdef HAVE_STDINT_H-# include <stdint.h>-#endif-#ifdef HAVE_UNISTD_H-# include <unistd.h>-#endif"--ac_subst_vars='LTLIBOBJS-LIBOBJS-cuda_c2hsflags-cuda_ldflags-cuda_cppflags-cuda_lib_dir-cuda_dir-EGREP-GREP-CPP-NVCC-target_os-target_vendor-target_cpu-target-host_os-host_vendor-host_cpu-host-build_os-build_vendor-build_cpu-build-OBJEXT-EXEEXT-ac_ct_CC-CPPFLAGS-LDFLAGS-CFLAGS-CC-target_alias-host_alias-build_alias-LIBS-ECHO_T-ECHO_N-ECHO_C-DEFS-mandir-localedir-libdir-psdir-pdfdir-dvidir-htmldir-infodir-docdir-oldincludedir-includedir-localstatedir-sharedstatedir-sysconfdir-datadir-datarootdir-libexecdir-sbindir-bindir-program_transform_name-prefix-exec_prefix-PACKAGE_URL-PACKAGE_BUGREPORT-PACKAGE_STRING-PACKAGE_VERSION-PACKAGE_TARNAME-PACKAGE_NAME-PATH_SEPARATOR-SHELL'-ac_subst_files=''-ac_user_opts='-enable_option_checking-'-      ac_precious_vars='build_alias-host_alias-target_alias-CC-CFLAGS-LDFLAGS-LIBS-CPPFLAGS-CPP'---# Initialize some variables set by options.-ac_init_help=-ac_init_version=false-ac_unrecognized_opts=-ac_unrecognized_sep=-# 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_TARNAME}'-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= ;;-  *)    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_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`-    # Reject names that are not valid shell variable names.-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&-      as_fn_error $? "invalid feature name: $ac_useropt"-    ac_useropt_orig=$ac_useropt-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`-    case $ac_user_opts in-      *"-"enable_$ac_useropt"-"*) ;;-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"-	 ac_unrecognized_sep=', ';;-    esac-    eval enable_$ac_useropt=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_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`-    # Reject names that are not valid shell variable names.-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&-      as_fn_error $? "invalid feature name: $ac_useropt"-    ac_useropt_orig=$ac_useropt-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`-    case $ac_user_opts in-      *"-"enable_$ac_useropt"-"*) ;;-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"-	 ac_unrecognized_sep=', ';;-    esac-    eval enable_$ac_useropt=\$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_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`-    # Reject names that are not valid shell variable names.-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&-      as_fn_error $? "invalid package name: $ac_useropt"-    ac_useropt_orig=$ac_useropt-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`-    case $ac_user_opts in-      *"-"with_$ac_useropt"-"*) ;;-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"-	 ac_unrecognized_sep=', ';;-    esac-    eval with_$ac_useropt=\$ac_optarg ;;--  -without-* | --without-*)-    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`-    # Reject names that are not valid shell variable names.-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&-      as_fn_error $? "invalid package name: $ac_useropt"-    ac_useropt_orig=$ac_useropt-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`-    case $ac_user_opts in-      *"-"with_$ac_useropt"-"*) ;;-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"-	 ac_unrecognized_sep=', ';;-    esac-    eval with_$ac_useropt=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 ;;--  -*) as_fn_error $? "unrecognized option: \`$ac_option'-Try \`$0 --help' for more information"-    ;;--  *=*)-    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`-    # Reject names that are not valid shell variable names.-    case $ac_envvar in #(-      '' | [0-9]* | *[!_$as_cr_alnum]* )-      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;-    esac-    eval $ac_envvar=\$ac_optarg-    export $ac_envvar ;;--  *)-    # FIXME: should be removed in autoconf 3.0.-    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2-    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&-      $as_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'`-  as_fn_error $? "missing argument to $ac_option"-fi--if test -n "$ac_unrecognized_opts"; then-  case $enable_option_checking in-    no) ;;-    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;-    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;-  esac-fi--# Check all directory arguments for consistency.-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-  # Remove trailing slashes.-  case $ac_val in-    */ )-      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`-      eval $ac_var=\$ac_val;;-  esac-  # Be sure to have absolute directory names.-  case $ac_val in-    [\\/$]* | ?:[\\/]* )  continue;;-    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;-  esac-  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"-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-  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 .` ||-  as_fn_error $? "working directory cannot be determined"-test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||-  as_fn_error $? "pwd does not report name of working directory"---# 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 -- "$as_myself" ||-$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \-	 X"$as_myself" : 'X\(//\)[^/]' \| \-	 X"$as_myself" : 'X\(//\)$' \| \-	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||-$as_echo X"$as_myself" |-    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 .."-  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"-fi-ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"-ac_abs_confdir=`(-	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"-	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 Haskell CUDA BLAS bindings 0.1.0.0 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/cublas]-  --htmldir=DIR           html documentation [DOCDIR]-  --dvidir=DIR            dvi documentation [DOCDIR]-  --pdfdir=DIR            pdf documentation [DOCDIR]-  --psdir=DIR             ps documentation [DOCDIR]-_ACEOF--  cat <<\_ACEOF--System types:-  --build=BUILD     configure for building on BUILD [guessed]-  --host=HOST       cross-compile to build programs to run on HOST [BUILD]-  --target=TARGET   configure for building compilers for TARGET [HOST]-_ACEOF-fi--if test -n "$ac_init_help"; then-  case $ac_init_help in-     short | recursive ) echo "Configuration of Haskell CUDA BLAS bindings 0.1.0.0:";;-   esac-  cat <<\_ACEOF--Some influential environment variables:-  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>-  LIBS        libraries to pass to the linker, e.g. -l<library>-  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if-              you have headers in a nonstandard directory <include dir>-  CPP         C preprocessor--Use these variables to override the choices made by `configure' or to help-it to find libraries and programs with nonstandard names/locations.--Report bugs to <tmcdonell@cse.unsw.edu.au>.-_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" ||-      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && 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=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`-  # A ".." for each directory in $ac_dir_suffix.-  ac_top_builddir_sub=`$as_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-      $as_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-Haskell CUDA BLAS bindings configure 0.1.0.0-generated by GNU Autoconf 2.69--Copyright (C) 2012 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--## ------------------------ ##-## Autoconf initialization. ##-## ------------------------ ##--# ac_fn_c_try_compile LINENO-# ---------------------------# Try to compile conftest.$ac_ext, and return whether this succeeded.-ac_fn_c_try_compile ()-{-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack-  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 ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""-$as_echo "$ac_try_echo"; } >&5-  (eval "$ac_compile") 2>conftest.err-  ac_status=$?-  if test -s conftest.err; then-    grep -v '^ *+' conftest.err >conftest.er1-    cat conftest.er1 >&5-    mv -f conftest.er1 conftest.err-  fi-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5-  test $ac_status = 0; } && {-	 test -z "$ac_c_werror_flag" ||-	 test ! -s conftest.err-       } && test -s conftest.$ac_objext; then :-  ac_retval=0-else-  $as_echo "$as_me: failed program was:" >&5-sed 's/^/| /' conftest.$ac_ext >&5--	ac_retval=1-fi-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno-  as_fn_set_status $ac_retval--} # ac_fn_c_try_compile--# ac_fn_c_try_cpp LINENO-# -----------------------# Try to preprocess conftest.$ac_ext, and return whether this succeeded.-ac_fn_c_try_cpp ()-{-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack-  if { { ac_try="$ac_cpp conftest.$ac_ext"-case "(($ac_try" in-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;-  *) ac_try_echo=$ac_try;;-esac-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""-$as_echo "$ac_try_echo"; } >&5-  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err-  ac_status=$?-  if test -s conftest.err; then-    grep -v '^ *+' conftest.err >conftest.er1-    cat conftest.er1 >&5-    mv -f conftest.er1 conftest.err-  fi-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5-  test $ac_status = 0; } > conftest.i && {-	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||-	 test ! -s conftest.err-       }; then :-  ac_retval=0-else-  $as_echo "$as_me: failed program was:" >&5-sed 's/^/| /' conftest.$ac_ext >&5--    ac_retval=1-fi-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno-  as_fn_set_status $ac_retval--} # ac_fn_c_try_cpp--# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES-# --------------------------------------------------------# Tests whether HEADER exists, giving a warning if it cannot be compiled using-# the include files in INCLUDES and setting the cache variable VAR-# accordingly.-ac_fn_c_check_header_mongrel ()-{-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack-  if eval \${$3+:} false; then :-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5-$as_echo_n "checking for $2... " >&6; }-if eval \${$3+:} false; then :-  $as_echo_n "(cached) " >&6-fi-eval ac_res=\$$3-	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5-$as_echo "$ac_res" >&6; }-else-  # Is the header compilable?-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5-$as_echo_n "checking $2 usability... " >&6; }-cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */-$4-#include <$2>-_ACEOF-if ac_fn_c_try_compile "$LINENO"; then :-  ac_header_compiler=yes-else-  ac_header_compiler=no-fi-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5-$as_echo "$ac_header_compiler" >&6; }--# Is the header present?-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5-$as_echo_n "checking $2 presence... " >&6; }-cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */-#include <$2>-_ACEOF-if ac_fn_c_try_cpp "$LINENO"; then :-  ac_header_preproc=yes-else-  ac_header_preproc=no-fi-rm -f conftest.err conftest.i conftest.$ac_ext-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5-$as_echo "$ac_header_preproc" >&6; }--# So?  What about this header?-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((-  yes:no: )-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5-$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5-$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}-    ;;-  no:yes:* )-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5-$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5-$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5-$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5-$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5-$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}-( $as_echo "## ---------------------------------------- ##-## Report this to tmcdonell@cse.unsw.edu.au ##-## ---------------------------------------- ##"-     ) | sed "s/^/$as_me: WARNING:     /" >&2-    ;;-esac-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5-$as_echo_n "checking for $2... " >&6; }-if eval \${$3+:} false; then :-  $as_echo_n "(cached) " >&6-else-  eval "$3=\$ac_header_compiler"-fi-eval ac_res=\$$3-	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5-$as_echo "$ac_res" >&6; }-fi-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno--} # ac_fn_c_check_header_mongrel--# ac_fn_c_try_run LINENO-# -----------------------# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes-# that executables *can* be run.-ac_fn_c_try_run ()-{-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack-  if { { ac_try="$ac_link"-case "(($ac_try" in-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;-  *) ac_try_echo=$ac_try;;-esac-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""-$as_echo "$ac_try_echo"; } >&5-  (eval "$ac_link") 2>&5-  ac_status=$?-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5-  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'-  { { case "(($ac_try" in-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;-  *) ac_try_echo=$ac_try;;-esac-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""-$as_echo "$ac_try_echo"; } >&5-  (eval "$ac_try") 2>&5-  ac_status=$?-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5-  test $ac_status = 0; }; }; then :-  ac_retval=0-else-  $as_echo "$as_me: program exited with status $ac_status" >&5-       $as_echo "$as_me: failed program was:" >&5-sed 's/^/| /' conftest.$ac_ext >&5--       ac_retval=$ac_status-fi-  rm -rf conftest.dSYM conftest_ipa8_conftest.oo-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno-  as_fn_set_status $ac_retval--} # ac_fn_c_try_run--# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES-# --------------------------------------------------------# Tests whether HEADER exists and can be compiled using the include files in-# INCLUDES, setting the cache variable VAR accordingly.-ac_fn_c_check_header_compile ()-{-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5-$as_echo_n "checking for $2... " >&6; }-if eval \${$3+:} false; then :-  $as_echo_n "(cached) " >&6-else-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */-$4-#include <$2>-_ACEOF-if ac_fn_c_try_compile "$LINENO"; then :-  eval "$3=yes"-else-  eval "$3=no"-fi-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext-fi-eval ac_res=\$$3-	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5-$as_echo "$ac_res" >&6; }-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno--} # ac_fn_c_check_header_compile--# ac_fn_c_try_link LINENO-# ------------------------# Try to link conftest.$ac_ext, and return whether this succeeded.-ac_fn_c_try_link ()-{-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack-  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 ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""-$as_echo "$ac_try_echo"; } >&5-  (eval "$ac_link") 2>conftest.err-  ac_status=$?-  if test -s conftest.err; then-    grep -v '^ *+' conftest.err >conftest.er1-    cat conftest.er1 >&5-    mv -f conftest.er1 conftest.err-  fi-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5-  test $ac_status = 0; } && {-	 test -z "$ac_c_werror_flag" ||-	 test ! -s conftest.err-       } && test -s conftest$ac_exeext && {-	 test "$cross_compiling" = yes ||-	 test -x conftest$ac_exeext-       }; then :-  ac_retval=0-else-  $as_echo "$as_me: failed program was:" >&5-sed 's/^/| /' conftest.$ac_ext >&5--	ac_retval=1-fi-  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information-  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would-  # interfere with the next link command; also delete a directory that is-  # left behind by Apple's compiler.  We do this before executing the actions.-  rm -rf conftest.dSYM conftest_ipa8_conftest.oo-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno-  as_fn_set_status $ac_retval--} # ac_fn_c_try_link-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 Haskell CUDA BLAS bindings $as_me 0.1.0.0, which was-generated by GNU Autoconf 2.69.  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=.-    $as_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=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;-    esac-    case $ac_pass in-    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;-    2)-      as_fn_append 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-      as_fn_append ac_configure_args " '$ac_arg'"-      ;;-    esac-  done-done-{ ac_configure_args0=; unset ac_configure_args0;}-{ ac_configure_args1=; unset 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--    $as_echo "## ---------------- ##-## Cache variables. ##-## ---------------- ##"-    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_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;-      esac-      case $ac_var in #(-      _ | IFS | as_nl) ;; #(-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(-      *) { eval $ac_var=; 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--    $as_echo "## ----------------- ##-## Output variables. ##-## ----------------- ##"-    echo-    for ac_var in $ac_subst_vars-    do-      eval ac_val=\$$ac_var-      case $ac_val in-      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;-      esac-      $as_echo "$ac_var='\''$ac_val'\''"-    done | sort-    echo--    if test -n "$ac_subst_files"; then-      $as_echo "## ------------------- ##-## File substitutions. ##-## ------------------- ##"-      echo-      for ac_var in $ac_subst_files-      do-	eval ac_val=\$$ac_var-	case $ac_val in-	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;-	esac-	$as_echo "$ac_var='\''$ac_val'\''"-      done | sort-      echo-    fi--    if test -s confdefs.h; then-      $as_echo "## ----------- ##-## confdefs.h. ##-## ----------- ##"-      echo-      cat confdefs.h-      echo-    fi-    test "$ac_signal" != 0 &&-      $as_echo "$as_me: caught signal $ac_signal"-    $as_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'; as_fn_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--$as_echo "/* confdefs.h */" > 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--cat >>confdefs.h <<_ACEOF-#define PACKAGE_URL "$PACKAGE_URL"-_ACEOF---# Let the site file select an alternate cache file if it wants to.-# Prefer an explicitly selected file to automatically selected ones.-ac_site_file1=NONE-ac_site_file2=NONE-if test -n "$CONFIG_SITE"; then-  # We do not want a PATH search for config.site.-  case $CONFIG_SITE in #((-    -*)  ac_site_file1=./$CONFIG_SITE;;-    */*) ac_site_file1=$CONFIG_SITE;;-    *)   ac_site_file1=./$CONFIG_SITE;;-  esac-elif test "x$prefix" != xNONE; then-  ac_site_file1=$prefix/share/config.site-  ac_site_file2=$prefix/etc/config.site-else-  ac_site_file1=$ac_default_prefix/share/config.site-  ac_site_file2=$ac_default_prefix/etc/config.site-fi-for ac_site_file in "$ac_site_file1" "$ac_site_file2"-do-  test "x$ac_site_file" = xNONE && continue-  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5-$as_echo "$as_me: loading site script $ac_site_file" >&6;}-    sed 's/^/| /' "$ac_site_file" >&5-    . "$ac_site_file" \-      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}-as_fn_error $? "failed to load site script $ac_site_file-See \`config.log' for more details" "$LINENO" 5; }-  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.  DJGPP emulates it as a regular file.-  if test /dev/null != "$cache_file" && test -f "$cache_file"; then-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5-$as_echo "$as_me: loading cache $cache_file" >&6;}-    case $cache_file in-      [\\/]* | ?:[\\/]* ) . "$cache_file";;-      *)                      . "./$cache_file";;-    esac-  fi-else-  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5-$as_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,)-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5-$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}-      ac_cache_corrupted=: ;;-    ,set)-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5-$as_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-	# differences in whitespace do not lead to failure.-	ac_old_val_w=`echo x $ac_old_val`-	ac_new_val_w=`echo x $ac_new_val`-	if test "$ac_old_val_w" != "$ac_new_val_w"; then-	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5-$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}-	  ac_cache_corrupted=:-	else-	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5-$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}-	  eval $ac_var=\$ac_old_val-	fi-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5-$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5-$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}-      fi;;-  esac-  # Pass precious variables to config.status.-  if test "$ac_new_set" = set; then-    case $ac_new_val in-    *\'*) ac_arg=$ac_var=`$as_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.-      *) as_fn_append ac_configure_args " '$ac_arg'" ;;-    esac-  fi-done-if $ac_cache_corrupted; then-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5-$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}-  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5-fi-## -------------------- ##-## Main body of script. ##-## -------------------- ##--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_config_files="$ac_config_files cublas.buildinfo"--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-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5-$as_echo_n "checking for $ac_word... " >&6; }-if ${ac_cv_prog_CC+:} false; then :-  $as_echo_n "(cached) " >&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 as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then-    ac_cv_prog_CC="${ac_tool_prefix}gcc"-    $as_echo "$as_me:${as_lineno-$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-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5-$as_echo "$CC" >&6; }-else-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5-$as_echo "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-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5-$as_echo_n "checking for $ac_word... " >&6; }-if ${ac_cv_prog_ac_ct_CC+:} false; then :-  $as_echo_n "(cached) " >&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 as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then-    ac_cv_prog_ac_ct_CC="gcc"-    $as_echo "$as_me:${as_lineno-$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-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5-$as_echo "$ac_ct_CC" >&6; }-else-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5-$as_echo "no" >&6; }-fi--  if test "x$ac_ct_CC" = x; then-    CC=""-  else-    case $cross_compiling:$ac_tool_warned in-yes:)-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&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-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5-$as_echo_n "checking for $ac_word... " >&6; }-if ${ac_cv_prog_CC+:} false; then :-  $as_echo_n "(cached) " >&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 as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then-    ac_cv_prog_CC="${ac_tool_prefix}cc"-    $as_echo "$as_me:${as_lineno-$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-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5-$as_echo "$CC" >&6; }-else-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5-$as_echo "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-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5-$as_echo_n "checking for $ac_word... " >&6; }-if ${ac_cv_prog_CC+:} false; then :-  $as_echo_n "(cached) " >&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 as_fn_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"-    $as_echo "$as_me:${as_lineno-$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-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5-$as_echo "$CC" >&6; }-else-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5-$as_echo "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-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5-$as_echo_n "checking for $ac_word... " >&6; }-if ${ac_cv_prog_CC+:} false; then :-  $as_echo_n "(cached) " >&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 as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then-    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"-    $as_echo "$as_me:${as_lineno-$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-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5-$as_echo "$CC" >&6; }-else-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5-$as_echo "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-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5-$as_echo_n "checking for $ac_word... " >&6; }-if ${ac_cv_prog_ac_ct_CC+:} false; then :-  $as_echo_n "(cached) " >&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 as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then-    ac_cv_prog_ac_ct_CC="$ac_prog"-    $as_echo "$as_me:${as_lineno-$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-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5-$as_echo "$ac_ct_CC" >&6; }-else-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5-$as_echo "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:)-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}-ac_tool_warned=yes ;;-esac-    CC=$ac_ct_CC-  fi-fi--fi---test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}-as_fn_error $? "no acceptable C compiler found in \$PATH-See \`config.log' for more details" "$LINENO" 5; }--# Provide some information about the compiler.-$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5-set X $ac_compile-ac_compiler=$2-for ac_option in --version -v -V -qversion; do-  { { ac_try="$ac_compiler $ac_option >&5"-case "(($ac_try" in-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;-  *) ac_try_echo=$ac_try;;-esac-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""-$as_echo "$ac_try_echo"; } >&5-  (eval "$ac_compiler $ac_option >&5") 2>conftest.err-  ac_status=$?-  if test -s conftest.err; then-    sed '10a\-... rest of stderr output deleted ...-         10q' conftest.err >conftest.er1-    cat conftest.er1 >&5-  fi-  rm -f conftest.er1 conftest.err-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5-  test $ac_status = 0; }-done--cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */--int-main ()-{--  ;-  return 0;-}-_ACEOF-ac_clean_files_save=$ac_clean_files-ac_clean_files="$ac_clean_files a.out a.out.dSYM 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.-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5-$as_echo_n "checking whether the C compiler works... " >&6; }-ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`--# The possible output files:-ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"--ac_rmfiles=-for ac_file in $ac_files-do-  case $ac_file in-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.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 ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""-$as_echo "$ac_try_echo"; } >&5-  (eval "$ac_link_default") 2>&5-  ac_status=$?-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5-  test $ac_status = 0; }; 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 | *.dSYM | *.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-  ac_file=''-fi-if test -z "$ac_file"; then :-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5-$as_echo "no" >&6; }-$as_echo "$as_me: failed program was:" >&5-sed 's/^/| /' conftest.$ac_ext >&5--{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}-as_fn_error 77 "C compiler cannot create executables-See \`config.log' for more details" "$LINENO" 5; }-else-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5-$as_echo "yes" >&6; }-fi-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5-$as_echo_n "checking for C compiler default output file name... " >&6; }-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5-$as_echo "$ac_file" >&6; }-ac_exeext=$ac_cv_exeext--rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out-ac_clean_files=$ac_clean_files_save-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5-$as_echo_n "checking for suffix of executables... " >&6; }-if { { ac_try="$ac_link"-case "(($ac_try" in-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;-  *) ac_try_echo=$ac_try;;-esac-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""-$as_echo "$ac_try_echo"; } >&5-  (eval "$ac_link") 2>&5-  ac_status=$?-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5-  test $ac_status = 0; }; 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 | *.dSYM | *.o | *.obj ) ;;-    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`-	  break;;-    * ) break;;-  esac-done-else-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}-as_fn_error $? "cannot compute suffix of executables: cannot compile and link-See \`config.log' for more details" "$LINENO" 5; }-fi-rm -f conftest conftest$ac_cv_exeext-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5-$as_echo "$ac_cv_exeext" >&6; }--rm -f conftest.$ac_ext-EXEEXT=$ac_cv_exeext-ac_exeext=$EXEEXT-cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */-#include <stdio.h>-int-main ()-{-FILE *f = fopen ("conftest.out", "w");- return ferror (f) || fclose (f) != 0;--  ;-  return 0;-}-_ACEOF-ac_clean_files="$ac_clean_files conftest.out"-# Check that the compiler produces executables we can run.  If not, either-# the compiler is broken, or we cross compile.-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5-$as_echo_n "checking whether we are cross compiling... " >&6; }-if test "$cross_compiling" != yes; then-  { { ac_try="$ac_link"-case "(($ac_try" in-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;-  *) ac_try_echo=$ac_try;;-esac-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""-$as_echo "$ac_try_echo"; } >&5-  (eval "$ac_link") 2>&5-  ac_status=$?-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5-  test $ac_status = 0; }-  if { ac_try='./conftest$ac_cv_exeext'-  { { case "(($ac_try" in-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;-  *) ac_try_echo=$ac_try;;-esac-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""-$as_echo "$ac_try_echo"; } >&5-  (eval "$ac_try") 2>&5-  ac_status=$?-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5-  test $ac_status = 0; }; }; then-    cross_compiling=no-  else-    if test "$cross_compiling" = maybe; then-	cross_compiling=yes-    else-	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}-as_fn_error $? "cannot run C compiled programs.-If you meant to cross compile, use \`--host'.-See \`config.log' for more details" "$LINENO" 5; }-    fi-  fi-fi-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5-$as_echo "$cross_compiling" >&6; }--rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out-ac_clean_files=$ac_clean_files_save-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5-$as_echo_n "checking for suffix of object files... " >&6; }-if ${ac_cv_objext+:} false; then :-  $as_echo_n "(cached) " >&6-else-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* 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 ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""-$as_echo "$ac_try_echo"; } >&5-  (eval "$ac_compile") 2>&5-  ac_status=$?-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5-  test $ac_status = 0; }; 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 | *.dSYM ) ;;-    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`-       break;;-  esac-done-else-  $as_echo "$as_me: failed program was:" >&5-sed 's/^/| /' conftest.$ac_ext >&5--{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}-as_fn_error $? "cannot compute suffix of object files: cannot compile-See \`config.log' for more details" "$LINENO" 5; }-fi-rm -f conftest.$ac_cv_objext conftest.$ac_ext-fi-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5-$as_echo "$ac_cv_objext" >&6; }-OBJEXT=$ac_cv_objext-ac_objext=$OBJEXT-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5-$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }-if ${ac_cv_c_compiler_gnu+:} false; then :-  $as_echo_n "(cached) " >&6-else-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */--int-main ()-{-#ifndef __GNUC__-       choke me-#endif--  ;-  return 0;-}-_ACEOF-if ac_fn_c_try_compile "$LINENO"; then :-  ac_compiler_gnu=yes-else-  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-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5-$as_echo "$ac_cv_c_compiler_gnu" >&6; }-if test $ac_compiler_gnu = yes; then-  GCC=yes-else-  GCC=-fi-ac_test_CFLAGS=${CFLAGS+set}-ac_save_CFLAGS=$CFLAGS-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5-$as_echo_n "checking whether $CC accepts -g... " >&6; }-if ${ac_cv_prog_cc_g+:} false; then :-  $as_echo_n "(cached) " >&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 confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */--int-main ()-{--  ;-  return 0;-}-_ACEOF-if ac_fn_c_try_compile "$LINENO"; then :-  ac_cv_prog_cc_g=yes-else-  CFLAGS=""-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */--int-main ()-{--  ;-  return 0;-}-_ACEOF-if ac_fn_c_try_compile "$LINENO"; then :--else-  ac_c_werror_flag=$ac_save_c_werror_flag-	 CFLAGS="-g"-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */--int-main ()-{--  ;-  return 0;-}-_ACEOF-if ac_fn_c_try_compile "$LINENO"; then :-  ac_cv_prog_cc_g=yes-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-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5-$as_echo "$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-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5-$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }-if ${ac_cv_prog_cc_c89+:} false; then :-  $as_echo_n "(cached) " >&6-else-  ac_cv_prog_cc_c89=no-ac_save_CC=$CC-cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */-#include <stdarg.h>-#include <stdio.h>-struct stat;-/* 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"-  if ac_fn_c_try_compile "$LINENO"; then :-  ac_cv_prog_cc_c89=$ac_arg-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)-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5-$as_echo "none needed" >&6; } ;;-  xno)-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5-$as_echo "unsupported" >&6; } ;;-  *)-    CC="$CC $ac_cv_prog_cc_c89"-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5-$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;-esac-if test "x$ac_cv_prog_cc_c89" != xno; then :--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---# Determine the target platform-#-ac_aux_dir=-for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do-  if test -f "$ac_dir/install-sh"; then-    ac_aux_dir=$ac_dir-    ac_install_sh="$ac_aux_dir/install-sh -c"-    break-  elif test -f "$ac_dir/install.sh"; then-    ac_aux_dir=$ac_dir-    ac_install_sh="$ac_aux_dir/install.sh -c"-    break-  elif test -f "$ac_dir/shtool"; then-    ac_aux_dir=$ac_dir-    ac_install_sh="$ac_aux_dir/shtool install -c"-    break-  fi-done-if test -z "$ac_aux_dir"; then-  as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5-fi--# These three variables are undocumented and unsupported,-# and are intended to be withdrawn in a future Autoconf release.-# They can cause serious problems if a builder's source tree is in a directory-# whose full name contains unusual characters.-ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.-ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.-ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.---# Make sure we can run config.sub.-$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||-  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5-$as_echo_n "checking build system type... " >&6; }-if ${ac_cv_build+:} false; then :-  $as_echo_n "(cached) " >&6-else-  ac_build_alias=$build_alias-test "x$ac_build_alias" = x &&-  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`-test "x$ac_build_alias" = x &&-  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5-ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||-  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5--fi-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5-$as_echo "$ac_cv_build" >&6; }-case $ac_cv_build in-*-*-*) ;;-*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;-esac-build=$ac_cv_build-ac_save_IFS=$IFS; IFS='-'-set x $ac_cv_build-shift-build_cpu=$1-build_vendor=$2-shift; shift-# Remember, the first character of IFS is used to create $*,-# except with old shells:-build_os=$*-IFS=$ac_save_IFS-case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac---{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5-$as_echo_n "checking host system type... " >&6; }-if ${ac_cv_host+:} false; then :-  $as_echo_n "(cached) " >&6-else-  if test "x$host_alias" = x; then-  ac_cv_host=$ac_cv_build-else-  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||-    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5-fi--fi-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5-$as_echo "$ac_cv_host" >&6; }-case $ac_cv_host in-*-*-*) ;;-*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;-esac-host=$ac_cv_host-ac_save_IFS=$IFS; IFS='-'-set x $ac_cv_host-shift-host_cpu=$1-host_vendor=$2-shift; shift-# Remember, the first character of IFS is used to create $*,-# except with old shells:-host_os=$*-IFS=$ac_save_IFS-case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac---{ $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5-$as_echo_n "checking target system type... " >&6; }-if ${ac_cv_target+:} false; then :-  $as_echo_n "(cached) " >&6-else-  if test "x$target_alias" = x; then-  ac_cv_target=$ac_cv_host-else-  ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||-    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5-fi--fi-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5-$as_echo "$ac_cv_target" >&6; }-case $ac_cv_target in-*-*-*) ;;-*) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;-esac-target=$ac_cv_target-ac_save_IFS=$IFS; IFS='-'-set x $ac_cv_target-shift-target_cpu=$1-target_vendor=$2-shift; shift-# Remember, the first character of IFS is used to create $*,-# except with old shells:-target_os=$*-IFS=$ac_save_IFS-case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac---# The aliases save the names the user supplied, while $host etc.-# will get canonicalized.-test -n "$target_alias" &&-  test "$program_prefix$program_suffix$program_transform_name" = \-    NONENONEs,x,x, &&-  program_prefix=${target_alias}---# Search the user's PATH for the 'nvcc' compiler. If it is found, add this-# prefix to the include and library search directories. Additionally, set nvcc-# as the C preprocessor for c2hs (only, or it won't try to link cudart)-#-# Extract the first word of "nvcc", so it can be a program name with args.-set dummy nvcc; ac_word=$2-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5-$as_echo_n "checking for $ac_word... " >&6; }-if ${ac_cv_path_NVCC+:} false; then :-  $as_echo_n "(cached) " >&6-else-  case $NVCC in-  [\\/]* | ?:[\\/]*)-  ac_cv_path_NVCC="$NVCC" # Let the user override the test with a path.-  ;;-  *)-  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 as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then-    ac_cv_path_NVCC="$as_dir/$ac_word$ac_exec_ext"-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5-    break 2-  fi-done-  done-IFS=$as_save_IFS--  ;;-esac-fi-NVCC=$ac_cv_path_NVCC-if test -n "$NVCC"; then-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NVCC" >&5-$as_echo "$NVCC" >&6; }-else-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5-$as_echo "no" >&6; }-fi---if test "$NVCC" != ""; then-    cuda_prefix="$(dirname "$(dirname "$NVCC")")"-    cuda_c2hsflags="--cpp="$NVCC" --cppopts=-E "-    cuda_dir="${cuda_prefix}/include"-    CPPFLAGS+=" "-I${cuda_dir}" "-#    CC=${NVCC}--    case $target in-    x86_64*) cuda_lib_dir="${cuda_prefix}/lib64" ;;-    *)       cuda_lib_dir="${cuda_prefix}/lib"   ;;-    esac-    LDFLAGS+=" -L${cuda_lib_dir} "-fi--# Recent versions of Mac OS X (10.6 and later) provides a C extension for-# creating lambda-like closure expressions (blocks), the syntax for which-# confuses the c2hs preprocessor. We disable this by undefining the __BLOCKS__-# macro.-#-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Apple Blocks extension" >&5-$as_echo_n "checking for Apple Blocks extension... " >&6; }-if test -r "/usr/include/stdlib.h"; then-    BLOCKS=`grep __BLOCKS__ /usr/include/stdlib.h`-fi-if test "$BLOCKS" != ""; then-    cuda_c2hsflags+="--cppopts=-U__BLOCKS__ "-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5-$as_echo "yes" >&6; }-else-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5-$as_echo "no" >&6; }-fi--# If we are running on Mac OS add the CUDA library path to the search list. This-# option allows applications to run without requiring to set [DY]LD_LIBRARY_PATH-#-case $build in-    *darwin* ) LDFLAGS+=" -Xlinker -rpath ${cuda_prefix}/lib " ;;-    * ) ;;-esac--# Make sure both the driver and runtime are found-#-longerror='-********************************************************************************--The configuration process failed to locate your CUDA installation. Ensure that-you have installed both the developer driver and toolkit, available from:--  http://developer.nvidia.com/cuda-downloads--and make sure that "nvcc" is available in your PATH. Check the above output log-and run the command directly to ensure it can be located.--If you have a non-standard installation, you can add additional search paths-using --extra-include-dirs and --extra-lib-dirs. Note that 64-bit Linux flavours-often require both "lib64" and "lib" library paths, in that order.--********************************************************************************'---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-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5-$as_echo_n "checking how to run the C preprocessor... " >&6; }-# On Suns, sometimes $CPP names a directory.-if test -n "$CPP" && test -d "$CPP"; then-  CPP=-fi-if test -z "$CPP"; then-  if ${ac_cv_prog_CPP+:} false; then :-  $as_echo_n "(cached) " >&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 confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */-#ifdef __STDC__-# include <limits.h>-#else-# include <assert.h>-#endif-		     Syntax error-_ACEOF-if ac_fn_c_try_cpp "$LINENO"; then :--else-  # Broken: fails on valid input.-continue-fi-rm -f conftest.err conftest.i conftest.$ac_ext--  # OK, works on sane cases.  Now check whether nonexistent headers-  # can be detected and how.-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */-#include <ac_nonexistent.h>-_ACEOF-if ac_fn_c_try_cpp "$LINENO"; then :-  # Broken: success on invalid input.-continue-else-  # Passes both tests.-ac_preproc_ok=:-break-fi-rm -f conftest.err conftest.i conftest.$ac_ext--done-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.-rm -f conftest.i 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-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5-$as_echo "$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 confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */-#ifdef __STDC__-# include <limits.h>-#else-# include <assert.h>-#endif-		     Syntax error-_ACEOF-if ac_fn_c_try_cpp "$LINENO"; then :--else-  # Broken: fails on valid input.-continue-fi-rm -f conftest.err conftest.i conftest.$ac_ext--  # OK, works on sane cases.  Now check whether nonexistent headers-  # can be detected and how.-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */-#include <ac_nonexistent.h>-_ACEOF-if ac_fn_c_try_cpp "$LINENO"; then :-  # Broken: success on invalid input.-continue-else-  # Passes both tests.-ac_preproc_ok=:-break-fi-rm -f conftest.err conftest.i conftest.$ac_ext--done-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.-rm -f conftest.i conftest.err conftest.$ac_ext-if $ac_preproc_ok; then :--else-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}-as_fn_error $? "C preprocessor \"$CPP\" fails sanity check-See \`config.log' for more details" "$LINENO" 5; }-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---{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5-$as_echo_n "checking for grep that handles long lines and -e... " >&6; }-if ${ac_cv_path_GREP+:} false; then :-  $as_echo_n "(cached) " >&6-else-  if test -z "$GREP"; then-  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"-      as_fn_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-  $as_echo_n 0123456789 >"conftest.in"-  while :-  do-    cat "conftest.in" "conftest.in" >"conftest.tmp"-    mv "conftest.tmp" "conftest.in"-    cp "conftest.in" "conftest.nl"-    $as_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-    as_fn_arith $ac_count + 1 && ac_count=$as_val-    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-  if test -z "$ac_cv_path_GREP"; then-    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5-  fi-else-  ac_cv_path_GREP=$GREP-fi--fi-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5-$as_echo "$ac_cv_path_GREP" >&6; }- GREP="$ac_cv_path_GREP"---{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5-$as_echo_n "checking for egrep... " >&6; }-if ${ac_cv_path_EGREP+:} false; then :-  $as_echo_n "(cached) " >&6-else-  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1-   then ac_cv_path_EGREP="$GREP -E"-   else-     if test -z "$EGREP"; then-  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"-      as_fn_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-  $as_echo_n 0123456789 >"conftest.in"-  while :-  do-    cat "conftest.in" "conftest.in" >"conftest.tmp"-    mv "conftest.tmp" "conftest.in"-    cp "conftest.in" "conftest.nl"-    $as_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-    as_fn_arith $ac_count + 1 && ac_count=$as_val-    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-  if test -z "$ac_cv_path_EGREP"; then-    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5-  fi-else-  ac_cv_path_EGREP=$EGREP-fi--   fi-fi-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5-$as_echo "$ac_cv_path_EGREP" >&6; }- EGREP="$ac_cv_path_EGREP"---{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5-$as_echo_n "checking for ANSI C header files... " >&6; }-if ${ac_cv_header_stdc+:} false; then :-  $as_echo_n "(cached) " >&6-else-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* end confdefs.h.  */-#include <stdlib.h>-#include <stdarg.h>-#include <string.h>-#include <float.h>--int-main ()-{--  ;-  return 0;-}-_ACEOF-if ac_fn_c_try_compile "$LINENO"; then :-  ac_cv_header_stdc=yes-else-  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 confdefs.h - <<_ACEOF >conftest.$ac_ext-/* 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 confdefs.h - <<_ACEOF >conftest.$ac_ext-/* 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 confdefs.h - <<_ACEOF >conftest.$ac_ext-/* 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-if ac_fn_c_try_run "$LINENO"; then :--else-  ac_cv_header_stdc=no-fi-rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \-  conftest.$ac_objext conftest.beam conftest.$ac_ext-fi--fi-fi-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5-$as_echo "$ac_cv_header_stdc" >&6; }-if test $ac_cv_header_stdc = yes; then--$as_echo "#define STDC_HEADERS 1" >>confdefs.h--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=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`-ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default-"-if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :-  cat >>confdefs.h <<_ACEOF-#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1-_ACEOF--fi--done---for ac_header in cublas_v2.h-do :-  ac_fn_c_check_header_mongrel "$LINENO" "cublas_v2.h" "ac_cv_header_cublas_v2_h" "$ac_includes_default"-if test "x$ac_cv_header_cublas_v2_h" = xyes; then :-  cat >>confdefs.h <<_ACEOF-#define HAVE_CUBLAS_V2_H 1-_ACEOF--else-  as_fn_error $? "could not find CUBLAS headers${longerror}" "$LINENO" 5-fi--done--for ac_header in cusparse_v2.h-do :-  ac_fn_c_check_header_mongrel "$LINENO" "cusparse_v2.h" "ac_cv_header_cusparse_v2_h" "$ac_includes_default"-if test "x$ac_cv_header_cusparse_v2_h" = xyes; then :-  cat >>confdefs.h <<_ACEOF-#define HAVE_CUSPARSE_V2_H 1-_ACEOF--else-  as_fn_error $? "could not find CUSPARSE headers${longerror}" "$LINENO" 5-fi--done--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing cublasGetVersion" >&5-$as_echo_n "checking for library containing cublasGetVersion... " >&6; }-if ${ac_cv_search_cublasGetVersion+:} false; then :-  $as_echo_n "(cached) " >&6-else-  ac_func_search_save_LIBS=$LIBS-cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* 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 cublasGetVersion ();-int-main ()-{-return cublasGetVersion ();-  ;-  return 0;-}-_ACEOF-for ac_lib in '' cublas; do-  if test -z "$ac_lib"; then-    ac_res="none required"-  else-    ac_res=-l$ac_lib-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"-  fi-  if ac_fn_c_try_link "$LINENO"; then :-  ac_cv_search_cublasGetVersion=$ac_res-fi-rm -f core conftest.err conftest.$ac_objext \-    conftest$ac_exeext-  if ${ac_cv_search_cublasGetVersion+:} false; then :-  break-fi-done-if ${ac_cv_search_cublasGetVersion+:} false; then :--else-  ac_cv_search_cublasGetVersion=no-fi-rm conftest.$ac_ext-LIBS=$ac_func_search_save_LIBS-fi-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_cublasGetVersion" >&5-$as_echo "$ac_cv_search_cublasGetVersion" >&6; }-ac_res=$ac_cv_search_cublasGetVersion-if test "$ac_res" != no; then :-  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"--else-  as_fn_error $? "could not find CUBLAS library${longerror}" "$LINENO" 5-fi--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing cusparseGetVersion" >&5-$as_echo_n "checking for library containing cusparseGetVersion... " >&6; }-if ${ac_cv_search_cusparseGetVersion+:} false; then :-  $as_echo_n "(cached) " >&6-else-  ac_func_search_save_LIBS=$LIBS-cat confdefs.h - <<_ACEOF >conftest.$ac_ext-/* 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 cusparseGetVersion ();-int-main ()-{-return cusparseGetVersion ();-  ;-  return 0;-}-_ACEOF-for ac_lib in '' cusparse; do-  if test -z "$ac_lib"; then-    ac_res="none required"-  else-    ac_res=-l$ac_lib-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"-  fi-  if ac_fn_c_try_link "$LINENO"; then :-  ac_cv_search_cusparseGetVersion=$ac_res-fi-rm -f core conftest.err conftest.$ac_objext \-    conftest$ac_exeext-  if ${ac_cv_search_cusparseGetVersion+:} false; then :-  break-fi-done-if ${ac_cv_search_cusparseGetVersion+:} false; then :--else-  ac_cv_search_cusparseGetVersion=no-fi-rm conftest.$ac_ext-LIBS=$ac_func_search_save_LIBS-fi-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_cusparseGetVersion" >&5-$as_echo "$ac_cv_search_cusparseGetVersion" >&6; }-ac_res=$ac_cv_search_cusparseGetVersion-if test "$ac_res" != no; then :-  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"--else-  as_fn_error $? "could not find CUSPARSE library${longerror}" "$LINENO" 5-fi---# Populate the buildinfo, with the search paths and any target specific options-#-cuda_cppflags="$CPPFLAGS "-cuda_ldflags="$LDFLAGS $LIBS "-------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_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;-      esac-      case $ac_var in #(-      _ | IFS | as_nl) ;; #(-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(-      *) { eval $ac_var=; 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-    if test "x$cache_file" != "x/dev/null"; then-      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5-$as_echo "$as_me: updating cache $cache_file" >&6;}-      if test ! -f "$cache_file" || test -h "$cache_file"; then-	cat confcache >"$cache_file"-      else-        case $cache_file in #(-        */* | ?:*)-	  mv -f confcache "$cache_file"$$ &&-	  mv -f "$cache_file"$$ "$cache_file" ;; #(-        *)-	  mv -f confcache "$cache_file" ;;-	esac-      fi-    fi-  else-    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5-$as_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='-:mline-/\\$/{- N- s,\\\n,,- b mline-}-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=-U=-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=`$as_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.-  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"-  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'-done-LIBOBJS=$ac_libobjs--LTLIBOBJS=$ac_ltlibobjs----: "${CONFIG_STATUS=./config.status}"-ac_write_fail=0-ac_clean_files_save=$ac_clean_files-ac_clean_files="$ac_clean_files $CONFIG_STATUS"-{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5-$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}-as_write_fail=0-cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1-#! $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}-export SHELL-_ASEOF-cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1-## -------------------- ##-## M4sh Initialization. ##-## -------------------- ##--# Be more Bourne compatible-DUALCASE=1; export DUALCASE # for MKS sh-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :-  emulate sh-  NULLCMD=:-  # Pre-4.2 versions of Zsh do 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---as_nl='-'-export as_nl-# Printing a long string crashes Solaris 7 /usr/bin/printf.-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo-# Prefer a ksh shell builtin over an external printf program on Solaris,-# but without wasting forks for bash or zsh.-if test -z "$BASH_VERSION$ZSH_VERSION" \-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then-  as_echo='print -r --'-  as_echo_n='print -rn --'-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then-  as_echo='printf %s\n'-  as_echo_n='printf %s'-else-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'-    as_echo_n='/usr/ucb/echo -n'-  else-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'-    as_echo_n_body='eval-      arg=$1;-      case $arg in #(-      *"$as_nl"*)-	expr "X$arg" : "X\\(.*\\)$as_nl";-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;-      esac;-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"-    '-    export as_echo_n_body-    as_echo_n='sh -c $as_echo_n_body as_echo'-  fi-  export as_echo_body-  as_echo='sh -c $as_echo_body as_echo'-fi--# The user is always right.-if test "${PATH_SEPARATOR+set}" != set; then-  PATH_SEPARATOR=:-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||-      PATH_SEPARATOR=';'-  }-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.)-IFS=" ""	$as_nl"--# Find who we are.  Look in the path if we contain no directory separator.-as_myself=-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-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2-  exit 1-fi--# Unset variables that we do not need and which cause bugs (e.g. in-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"-# suppresses any "Segmentation fault" message there.  '((' could-# trigger a bug in pdksh 5.2.14.-for as_var in BASH_ENV ENV MAIL MAILPATH-do eval test x\${$as_var+set} = xset \-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :-done-PS1='$ '-PS2='> '-PS4='+ '--# NLS nuisances.-LC_ALL=C-export LC_ALL-LANGUAGE=C-export LANGUAGE--# CDPATH.-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH---# as_fn_error STATUS ERROR [LINENO LOG_FD]-# -----------------------------------------# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the-# script with STATUS, using 1 if that was 0.-as_fn_error ()-{-  as_status=$1; test $as_status -eq 0 && as_status=1-  if test "$4"; then-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4-  fi-  $as_echo "$as_me: error: $2" >&2-  as_fn_exit $as_status-} # as_fn_error---# as_fn_set_status STATUS-# ------------------------# Set $? to STATUS, without forking.-as_fn_set_status ()-{-  return $1-} # as_fn_set_status--# as_fn_exit STATUS-# ------------------# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.-as_fn_exit ()-{-  set +e-  as_fn_set_status $1-  exit $1-} # as_fn_exit--# as_fn_unset VAR-# ----------------# Portably unset VAR.-as_fn_unset ()-{-  { eval $1=; unset $1;}-}-as_unset=as_fn_unset-# as_fn_append VAR VALUE-# -----------------------# Append the text in VALUE to the end of the definition contained in VAR. Take-# advantage of any shell optimizations that allow amortized linear growth over-# repeated appends, instead of the typical quadratic growth present in naive-# implementations.-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :-  eval 'as_fn_append ()-  {-    eval $1+=\$2-  }'-else-  as_fn_append ()-  {-    eval $1=\$$1\$2-  }-fi # as_fn_append--# as_fn_arith ARG...-# -------------------# Perform arithmetic evaluation on the ARGs, and store the result in the-# global $as_val. Take advantage of shells that can avoid forks. The arguments-# must be portable across $(()) and expr.-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :-  eval 'as_fn_arith ()-  {-    as_val=$(( $* ))-  }'-else-  as_fn_arith ()-  {-    as_val=`expr "$@" || test $? -eq 1`-  }-fi # as_fn_arith---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--if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then-  as_dirname=dirname-else-  as_dirname=false-fi--as_me=`$as_basename -- "$0" ||-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \-	 X"$0" : 'X\(//\)$' \| \-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||-$as_echo X/"$0" |-    sed '/^.*\/\([^/][^/]*\)\/*$/{-	    s//\1/-	    q-	  }-	  /^X\/\(\/\/\)$/{-	    s//\1/-	    q-	  }-	  /^X\/\(\/\).*/{-	    s//\1/-	    q-	  }-	  s/.*/./; q'`--# 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--ECHO_C= ECHO_N= ECHO_T=-case `echo -n x` in #(((((--n*)-  case `echo 'xy\c'` in-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.-  xy)  ECHO_C='\c';;-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null-       ECHO_T='	';;-  esac;;-*)-  ECHO_N='-n';;-esac--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 2>/dev/null-fi-if (echo >conf$$.file) 2>/dev/null; then-  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 -pR'.-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||-      as_ln_s='cp -pR'-  elif ln conf$$.file conf$$ 2>/dev/null; then-    as_ln_s=ln-  else-    as_ln_s='cp -pR'-  fi-else-  as_ln_s='cp -pR'-fi-rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file-rmdir conf$$.dir 2>/dev/null---# as_fn_mkdir_p-# --------------# Create "$as_dir" as a directory, including parents if necessary.-as_fn_mkdir_p ()-{--  case $as_dir in #(-  -*) as_dir=./$as_dir;;-  esac-  test -d "$as_dir" || eval $as_mkdir_p || {-    as_dirs=-    while :; do-      case $as_dir in #(-      *\'*) as_qdir=`$as_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 ||-$as_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" || as_fn_error $? "cannot create directory $as_dir"---} # as_fn_mkdir_p-if mkdir -p . 2>/dev/null; then-  as_mkdir_p='mkdir -p "$as_dir"'-else-  test -d ./-p && rmdir ./-p-  as_mkdir_p=false-fi---# as_fn_executable_p FILE-# ------------------------# Test if FILE is an executable regular file.-as_fn_executable_p ()-{-  test -f "$1" && test -x "$1"-} # as_fn_executable_p-as_test_x='test -x'-as_executable_p=as_fn_executable_p--# 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-## ----------------------------------- ##-## Main body of $CONFIG_STATUS script. ##-## ----------------------------------- ##-_ASEOF-test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1--cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=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 Haskell CUDA BLAS bindings $as_me 0.1.0.0, which was-generated by GNU Autoconf 2.69.  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--case $ac_config_files in *"-"*) set x $ac_config_files; shift; ac_config_files=$*;;-esac----cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1-# Files that config.status was made for.-config_files="$ac_config_files"--_ACEOF--cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1-ac_cs_usage="\-\`$as_me' instantiates files and other configuration actions-from templates according to the current configuration.  Unless the files-and actions are specified as TAGs, all are instantiated by default.--Usage: $0 [OPTION]... [TAG]...--  -h, --help       print this help, then exit-  -V, --version    print version number and configuration settings, then exit-      --config     print configuration, then exit-  -q, --quiet, --silent-                   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 <tmcdonell@cse.unsw.edu.au>."--_ACEOF-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1-ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"-ac_cs_version="\\-Haskell CUDA BLAS bindings config.status 0.1.0.0-configured by $0, generated by GNU Autoconf 2.69,-  with options \\"\$ac_cs_config\\"--Copyright (C) 2012 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'-test -n "\$AWK" || AWK=awk-_ACEOF--cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1-# The default lists apply if the user does not specify any file.-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=`expr "X$1" : 'X\([^=]*\)='`-    ac_optarg=-    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 )-    $as_echo "$ac_cs_version"; exit ;;-  --config | --confi | --conf | --con | --co | --c )-    $as_echo "$ac_cs_config"; exit ;;-  --debug | --debu | --deb | --de | --d | -d )-    debug=: ;;-  --file | --fil | --fi | --f )-    $ac_shift-    case $ac_optarg in-    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;-    '') as_fn_error $? "missing file argument" ;;-    esac-    as_fn_append CONFIG_FILES " '$ac_optarg'"-    ac_need_defaults=false;;-  --he | --h |  --help | --hel | -h )-    $as_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.-  -*) as_fn_error $? "unrecognized option: \`$1'-Try \`$0 --help' for more information." ;;--  *) as_fn_append 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 || ac_write_fail=1-if \$ac_cs_recheck; then-  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion-  shift-  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6-  CONFIG_SHELL='$SHELL'-  export CONFIG_SHELL-  exec "\$@"-fi--_ACEOF-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1-exec 5>>config.log-{-  echo-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX-## Running $as_me. ##-_ASBOX-  $as_echo "$ac_log"-} >&5--_ACEOF-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1-_ACEOF--cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1--# Handling of arguments.-for ac_config_target in $ac_config_targets-do-  case $ac_config_target in-    "cublas.buildinfo") CONFIG_FILES="$CONFIG_FILES cublas.buildinfo" ;;--  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;-  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= ac_tmp=-  trap 'exit_status=$?-  : "${ac_tmp:=$tmp}"-  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status-' 0-  trap 'as_fn_exit 1' 1 2 13 15-}-# Create a (secure) tmp directory for tmp files.--{-  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&-  test -d "$tmp"-}  ||-{-  tmp=./conf$$-$RANDOM-  (umask 077 && mkdir "$tmp")-} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5-ac_tmp=$tmp--# Set up the scripts for CONFIG_FILES section.-# No need to generate them if there are no CONFIG_FILES.-# This happens for instance with `./config.status config.h'.-if test -n "$CONFIG_FILES"; then---ac_cr=`echo X | tr X '\015'`-# On cygwin, bash can eat \r inside `` if the user requested igncr.-# But we know of no other shell where ac_cr would be empty at this-# point, so we can use a bashism as a fallback.-if test "x$ac_cr" = x; then-  eval ac_cr=\$\'\\r\'-fi-ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`-if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then-  ac_cs_awk_cr='\\r'-else-  ac_cs_awk_cr=$ac_cr-fi--echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&-_ACEOF---{-  echo "cat >conf$$subs.awk <<_ACEOF" &&-  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&-  echo "_ACEOF"-} >conf$$subs.sh ||-  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5-ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`-ac_delim='%!_!# '-for ac_last_try in false false false false false :; do-  . ./conf$$subs.sh ||-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5--  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`-  if test $ac_delim_n = $ac_delim_num; then-    break-  elif $ac_last_try; then-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5-  else-    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "-  fi-done-rm -f conf$$subs.sh--cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1-cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&-_ACEOF-sed -n '-h-s/^/S["/; s/!.*/"]=/-p-g-s/^[^!]*!//-:repl-t repl-s/'"$ac_delim"'$//-t delim-:nl-h-s/\(.\{148\}\)..*/\1/-t more1-s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/-p-n-b repl-:more1-s/["\\]/\\&/g; s/^/"/; s/$/"\\/-p-g-s/.\{148\}//-t nl-:delim-h-s/\(.\{148\}\)..*/\1/-t more2-s/["\\]/\\&/g; s/^/"/; s/$/"/-p-b-:more2-s/["\\]/\\&/g; s/^/"/; s/$/"\\/-p-g-s/.\{148\}//-t delim-' <conf$$subs.awk | sed '-/^[^""]/{-  N-  s/\n//-}-' >>$CONFIG_STATUS || ac_write_fail=1-rm -f conf$$subs.awk-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1-_ACAWK-cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&-  for (key in S) S_is_set[key] = 1-  FS = ""--}-{-  line = $ 0-  nfields = split(line, field, "@")-  substed = 0-  len = length(field[1])-  for (i = 2; i < nfields; i++) {-    key = field[i]-    keylen = length(key)-    if (S_is_set[key]) {-      value = S[key]-      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)-      len += length(value) + length(field[++i])-      substed = 1-    } else-      len += 1 + keylen-  }--  print line-}--_ACAWK-_ACEOF-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1-if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then-  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"-else-  cat-fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \-  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5-_ACEOF--# VPATH may cause trouble with some makes, so we remove sole $(srcdir),-# ${srcdir} and @srcdir@ entries 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[	 ]*=[	 ]*/{-h-s///-s/^/:/-s/[	 ]*$/:/-s/:\$(srcdir):/:/g-s/:\${srcdir}:/:/g-s/:@srcdir@:/:/g-s/^:*//-s/:*$//-x-s/\(=[	 ]*\).*/\1/-G-s/\n//-s/^[^=]*=[	 ]*$//-}'-fi--cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1-fi # test -n "$CONFIG_FILES"---eval set X "  :F $CONFIG_FILES      "-shift-for ac_tag-do-  case $ac_tag in-  :[FHLC]) ac_mode=$ac_tag; continue;;-  esac-  case $ac_mode$ac_tag in-  :[FHL]*:*);;-  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;-  :[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="$ac_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 ||-	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;-      esac-      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac-      as_fn_append 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 '`-	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'-	`' by configure.'-    if test x"$ac_file" != x-; then-      configure_input="$ac_file.  $configure_input"-      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5-$as_echo "$as_me: creating $ac_file" >&6;}-    fi-    # Neutralize special characters interpreted by sed in replacement strings.-    case $configure_input in #(-    *\&* | *\|* | *\\* )-       ac_sed_conf_input=`$as_echo "$configure_input" |-       sed 's/[\\\\&|]/\\\\&/g'`;; #(-    *) ac_sed_conf_input=$configure_input;;-    esac--    case $ac_tag in-    *:-:* | *:-) cat >"$ac_tmp/stdin" \-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;-    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 ||-$as_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"; as_fn_mkdir_p-  ac_builddir=.--case "$ac_dir" in-.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;-*)-  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`-  # A ".." for each directory in $ac_dir_suffix.-  ac_top_builddir_sub=`$as_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 || ac_write_fail=1-# 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=-ac_sed_dataroot='-/datarootdir/ {-  p-  q-}-/@datadir@/p-/@docdir@/p-/@infodir@/p-/@localedir@/p-/@mandir@/p'-case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in-*datarootdir*) ac_datarootdir_seen=yes;;-*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5-$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}-_ACEOF-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1-  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 || ac_write_fail=1-ac_sed_extra="$ac_vpsub-$extrasub-_ACEOF-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1-:t-/@[a-zA-Z_][a-zA-Z_0-9]*@/!b-s|@configure_input@|$ac_sed_conf_input|;t t-s&@top_builddir@&$ac_top_builddir_sub&;t t-s&@top_build_prefix@&$ac_top_build_prefix&;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-"-eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \-  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5--test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&-  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&-  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \-      "$ac_tmp/out"`; test -z "$ac_out"; } &&-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'-which seems to be undefined.  Please make sure it is defined" >&5-$as_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 "$ac_tmp/stdin"-  case $ac_file in-  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;-  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;-  esac \-  || as_fn_error $? "could not create $ac_file" "$LINENO" 5- ;;----  esac--done # for ac_tag---as_fn_exit 0-_ACEOF-ac_clean_files=$ac_clean_files_save--test $ac_write_fail = 0 ||-  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5---# 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 || as_fn_exit 1-fi-if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5-$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}-fi--
− configure.ac 
@@ -1,88 +0,0 @@-AC_INIT([Haskell CUDA BLAS bindings], [0.1.0.0], [tmcdonell@cse.unsw.edu.au], [cublas])-AC_CONFIG_SRCDIR([Foreign/CUDA/Cublas.hs])-AC_CONFIG_FILES([cublas.buildinfo])-AC_PROG_CC--# Determine the target platform-#-AC_CANONICAL_TARGET--# Search the user's PATH for the 'nvcc' compiler. If it is found, add this-# prefix to the include and library search directories. Additionally, set nvcc-# as the C preprocessor for c2hs (only, or it won't try to link cudart)-#-AC_PATH_PROG(NVCC, nvcc)-if test "$NVCC" != ""; then-    cuda_prefix="$(dirname "$(dirname "$NVCC")")"-    cuda_c2hsflags="--cpp="$NVCC" --cppopts=-E "-    cuda_dir="${cuda_prefix}/include"-    CPPFLAGS+=" "-I${cuda_dir}" "-#    CC=${NVCC}--    case $target in-    x86_64*) cuda_lib_dir="${cuda_prefix}/lib64" ;;-    *)       cuda_lib_dir="${cuda_prefix}/lib"   ;;-    esac-    LDFLAGS+=" -L${cuda_lib_dir} "-fi--# Recent versions of Mac OS X (10.6 and later) provides a C extension for-# creating lambda-like closure expressions (blocks), the syntax for which-# confuses the c2hs preprocessor. We disable this by undefining the __BLOCKS__-# macro.-#-AC_MSG_CHECKING(for Apple Blocks extension)-if test -r "/usr/include/stdlib.h"; then-    BLOCKS=`grep __BLOCKS__ /usr/include/stdlib.h`-fi-if test "$BLOCKS" != ""; then-    cuda_c2hsflags+="--cppopts=-U__BLOCKS__ "-    AC_MSG_RESULT(yes)-else-    AC_MSG_RESULT(no)-fi--# If we are running on Mac OS add the CUDA library path to the search list. This-# option allows applications to run without requiring to set [DY]LD_LIBRARY_PATH-#-case $build in-    *darwin* ) LDFLAGS+=" -Xlinker -rpath ${cuda_prefix}/lib " ;;-    * ) ;;-esac--# Make sure both the driver and runtime are found-#-longerror='-********************************************************************************--The configuration process failed to locate your CUDA installation. Ensure that-you have installed both the developer driver and toolkit, available from:--  http://developer.nvidia.com/cuda-downloads--and make sure that "nvcc" is available in your PATH. Check the above output log-and run the command directly to ensure it can be located.--If you have a non-standard installation, you can add additional search paths-using --extra-include-dirs and --extra-lib-dirs. Note that 64-bit Linux flavours-often require both "lib64" and "lib" library paths, in that order.--********************************************************************************'--AC_CHECK_HEADERS([cublas_v2.h],          [], [AC_MSG_ERROR(could not find CUBLAS headers${longerror})])-AC_CHECK_HEADERS([cusparse_v2.h],          [], [AC_MSG_ERROR(could not find CUSPARSE headers${longerror})])-AC_SEARCH_LIBS(cublasGetVersion, cublas, [], [AC_MSG_ERROR(could not find CUBLAS library${longerror})])-AC_SEARCH_LIBS(cusparseGetVersion, cusparse, [], [AC_MSG_ERROR(could not find CUSPARSE library${longerror})])--# Populate the buildinfo, with the search paths and any target specific options-#-cuda_cppflags="$CPPFLAGS "-cuda_ldflags="$LDFLAGS $LIBS "--AC_SUBST([cuda_dir])-AC_SUBST([cuda_lib_dir])-AC_SUBST([cuda_cppflags])-AC_SUBST([cuda_ldflags])-AC_SUBST([cuda_c2hsflags])-AC_OUTPUT-
− cublas.buildinfo.in 
@@ -1,9 +0,0 @@-ghc-options: -optc@cuda_cppflags@-cc-options: @cuda_cppflags@-ld-options: @cuda_ldflags@-x-extra-c2hs-options: @cuda_c2hsflags@--include-dirs: @cuda_dir@-extra-lib-dirs:  @cuda_lib_dir@--cpp-options: -DCUDA_INCLUDE_DIR="@cuda_dir@"
cublas.cabal view
@@ -1,65 +1,80 @@ name:                   cublas-version:                0.2.1.0-synopsis:               FFI bindings to the CUDA CUBLAS and CUSPARSE libraries-description:            -  This package provides FFI bindings to the NVIDIA CUDA CUBLAS and CUSPARSE-  linear algebra GPU BLAS implementations. The modules-  @Foreign.CUDA.Cublas@ and @Foreign.CUDA.Cusparse@ are probably the most-  useful.-  .-  Requires CUDA version 6.5.-  .-  If you have trouble installing this package, it may help to view the Github-  page: <http://github.com/bmsherman/cublas>-  .+version:                0.3.0.0+synopsis:               FFI bindings to the CUDA BLAS library+description:+    The cuBLAS library is an implementation of BLAS (Basic Linear Algebra+    Subprograms) for NVIDIA GPUs. This package provides FFI bindings to the+    functions of the cuBLAS library. You will need to install the CUDA driver+    and developer toolkit:+    .+    <http://developer.nvidia.com/cuda-downloads>+    .+    See the <https://travis-ci.org/tmcdonell/cublas travis-ci.org> build matrix+    for tested CUDA library versions.+ license:                BSD3-homepage:               https://github.com/bmsherman/cublas license-file:           LICENSE author:                 Trevor L. McDonell, Ben Sherman-maintainer:             Ben Sherman <benmsherman@gmail.com>-copyright:              Copyright (c) [2012..2014]. Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>, Ben Sherman <benmsherman@gmail.com>+maintainer:             Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>+copyright:              Copyright (c) [2012..2017]. Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>, Ben Sherman <benmsherman@gmail.com> category:               Foreign cabal-version:          >=1.8  build-type:             Custom-Extra-tmp-files:        cublas.buildinfo config.status config.log-Extra-source-files:     configure-                        configure.ac-                        config.guess-                        config.sub-                        install-sh-                        cublas.buildinfo.in+extra-tmp-files:        cublas.buildinfo.generated+extra-source-files:+  README.md+  CHANGELOG.md+  cbits/stubs.h +custom-setup+  setup-depends:+      base              >= 4.6+    , Cabal             >= 1.22+    , cuda              >= 0.8+    , directory         >= 1.0+    , filepath          >= 1.0+ library-  exposed-modules:      Foreign.CUDA.Cublas-                        Foreign.CUDA.Cublas.Error-                        Foreign.CUDA.Cublas.Types-                        Foreign.CUDA.Cublas.FFI-                        Foreign.CUDA.Cusparse-                        Foreign.CUDA.Cusparse.Error-                        Foreign.CUDA.Cusparse.Types-                        Foreign.CUDA.Cusparse.FFI+  hs-source-dirs:       .+  include-dirs:         . -  other-modules:        Foreign.CUDA.Cublas.TH-       +  exposed-modules:+      Foreign.CUDA.BLAS+      Foreign.CUDA.BLAS.Context+      Foreign.CUDA.BLAS.Error+      Foreign.CUDA.BLAS.Level1+      Foreign.CUDA.BLAS.Level2+      Foreign.CUDA.BLAS.Level3+      Foreign.CUDA.BLAS.Stream -  build-depends:        base >=4.4 && <4.8,-                        cuda >=0.4.1 && <0.7,-                        filepath >=1.3 && <1.4,-                        language-c >=0.4.2 && <0.5,-                        template-haskell >=2.7 && <2.10,-                        storable-complex >=0.2.1 && <0.3-  other-extensions:     ForeignFunctionInterface, TemplateHaskell, CPP+  other-modules:+      Foreign.CUDA.BLAS.Internal.C2HS+      Foreign.CUDA.BLAS.Internal.Types -  build-tools:          c2hs >= 0.16-  ghc-options:          -funbox-strict-fields -fwarn-tabs -fno-warn-name-shadowing-  extra-libraries:      cublas, cusparse+  build-depends:+      base                              == 4.*+    , cuda                              >= 0.8+    , half                              >= 0.1+    , storable-complex                  >= 0.2 +  build-tools:+      c2hs                              >= 0.16++  ghc-options:+      -Wall+      -O2+      -funbox-strict-fields+      -fwarn-tabs+      -fno-warn-unused-imports+ source-repository head-  Type:     git-  Location: git://github.com/bmsherman/cublas.git+    type:               git+    location:           https://github.com/tmcdonell/cublas  source-repository this-  Type:     git-  Location: git://github.com/bmsherman/cublas/releases/tag/0.2.1.0.git-  Tag:      0.2.1.0+    type:               git+    location:           https://github.com/tmcdonell/cublas+    tag:                0.3.0.0++-- vim: nospell
− install-sh 
@@ -1,519 +0,0 @@-#!/bin/sh-# install - install a program, script, or datafile--scriptversion=2006-12-25.00--# This originates from X11R5 (mit/util/scripts/install.sh), which was-# later released in X11R6 (xc/config/util/install.sh) with the-# following copyright and license.-#-# Copyright (C) 1994 X Consortium-#-# Permission is hereby granted, free of charge, to any person obtaining a copy-# of this software and associated documentation files (the "Software"), to-# deal in the Software without restriction, including without limitation the-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or-# sell copies of the Software, and to permit persons to whom the Software is-# furnished to do so, subject to the following conditions:-#-# The above copyright notice and this permission notice shall be included in-# all copies or substantial portions of the Software.-#-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE-# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN-# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC--# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.-#-# Except as contained in this notice, the name of the X Consortium shall not-# be used in advertising or otherwise to promote the sale, use or other deal--# ings in this Software without prior written authorization from the X Consor--# tium.-#-#-# FSF changes to this file are in the public domain.-#-# Calling this script install-sh is preferred over install.sh, to prevent-# `make' implicit rules from creating a file called install from it-# when there is no Makefile.-#-# This script is compatible with the BSD install script, but was written-# from scratch.--nl='-'-IFS=" ""	$nl"--# set DOITPROG to echo to test this script--# Don't use :- since 4.3BSD and earlier shells don't like it.-doit=${DOITPROG-}-if test -z "$doit"; then-  doit_exec=exec-else-  doit_exec=$doit-fi--# Put in absolute file names if you don't have them in your path;-# or use environment vars.--chgrpprog=${CHGRPPROG-chgrp}-chmodprog=${CHMODPROG-chmod}-chownprog=${CHOWNPROG-chown}-cmpprog=${CMPPROG-cmp}-cpprog=${CPPROG-cp}-mkdirprog=${MKDIRPROG-mkdir}-mvprog=${MVPROG-mv}-rmprog=${RMPROG-rm}-stripprog=${STRIPPROG-strip}--posix_glob='?'-initialize_posix_glob='-  test "$posix_glob" != "?" || {-    if (set -f) 2>/dev/null; then-      posix_glob=-    else-      posix_glob=:-    fi-  }-'--posix_mkdir=--# Desired mode of installed file.-mode=0755--chgrpcmd=-chmodcmd=$chmodprog-chowncmd=-mvcmd=$mvprog-rmcmd="$rmprog -f"-stripcmd=--src=-dst=-dir_arg=-dst_arg=--copy_on_change=false-no_target_directory=--usage="\-Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE-   or: $0 [OPTION]... SRCFILES... DIRECTORY-   or: $0 [OPTION]... -t DIRECTORY SRCFILES...-   or: $0 [OPTION]... -d DIRECTORIES...--In the 1st form, copy SRCFILE to DSTFILE.-In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.-In the 4th, create DIRECTORIES.--Options:-     --help     display this help and exit.-     --version  display version info and exit.--  -c            (ignored)-  -C            install only if different (preserve the last data modification time)-  -d            create directories instead of installing files.-  -g GROUP      $chgrpprog installed files to GROUP.-  -m MODE       $chmodprog installed files to MODE.-  -o USER       $chownprog installed files to USER.-  -s            $stripprog installed files.-  -t DIRECTORY  install into DIRECTORY.-  -T            report an error if DSTFILE is a directory.--Environment variables override the default commands:-  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG-  RMPROG STRIPPROG-"--while test $# -ne 0; do-  case $1 in-    -c) ;;--    -C) copy_on_change=true;;--    -d) dir_arg=true;;--    -g) chgrpcmd="$chgrpprog $2"-	shift;;--    --help) echo "$usage"; exit $?;;--    -m) mode=$2-	case $mode in-	  *' '* | *'	'* | *'-'*	  | *'*'* | *'?'* | *'['*)-	    echo "$0: invalid mode: $mode" >&2-	    exit 1;;-	esac-	shift;;--    -o) chowncmd="$chownprog $2"-	shift;;--    -s) stripcmd=$stripprog;;--    -t) dst_arg=$2-	shift;;--    -T) no_target_directory=true;;--    --version) echo "$0 $scriptversion"; exit $?;;--    --)	shift-	break;;--    -*)	echo "$0: invalid option: $1" >&2-	exit 1;;--    *)  break;;-  esac-  shift-done--if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then-  # When -d is used, all remaining arguments are directories to create.-  # When -t is used, the destination is already specified.-  # Otherwise, the last argument is the destination.  Remove it from $@.-  for arg-  do-    if test -n "$dst_arg"; then-      # $@ is not empty: it contains at least $arg.-      set fnord "$@" "$dst_arg"-      shift # fnord-    fi-    shift # arg-    dst_arg=$arg-  done-fi--if test $# -eq 0; then-  if test -z "$dir_arg"; then-    echo "$0: no input file specified." >&2-    exit 1-  fi-  # It's OK to call `install-sh -d' without argument.-  # This can happen when creating conditional directories.-  exit 0-fi--if test -z "$dir_arg"; then-  trap '(exit $?); exit' 1 2 13 15--  # Set umask so as not to create temps with too-generous modes.-  # However, 'strip' requires both read and write access to temps.-  case $mode in-    # Optimize common cases.-    *644) cp_umask=133;;-    *755) cp_umask=22;;--    *[0-7])-      if test -z "$stripcmd"; then-	u_plus_rw=-      else-	u_plus_rw='% 200'-      fi-      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;-    *)-      if test -z "$stripcmd"; then-	u_plus_rw=-      else-	u_plus_rw=,u+rw-      fi-      cp_umask=$mode$u_plus_rw;;-  esac-fi--for src-do-  # Protect names starting with `-'.-  case $src in-    -*) src=./$src;;-  esac--  if test -n "$dir_arg"; then-    dst=$src-    dstdir=$dst-    test -d "$dstdir"-    dstdir_status=$?-  else--    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command-    # might cause directories to be created, which would be especially bad-    # if $src (and thus $dsttmp) contains '*'.-    if test ! -f "$src" && test ! -d "$src"; then-      echo "$0: $src does not exist." >&2-      exit 1-    fi--    if test -z "$dst_arg"; then-      echo "$0: no destination specified." >&2-      exit 1-    fi--    dst=$dst_arg-    # Protect names starting with `-'.-    case $dst in-      -*) dst=./$dst;;-    esac--    # If destination is a directory, append the input filename; won't work-    # if double slashes aren't ignored.-    if test -d "$dst"; then-      if test -n "$no_target_directory"; then-	echo "$0: $dst_arg: Is a directory" >&2-	exit 1-      fi-      dstdir=$dst-      dst=$dstdir/`basename "$src"`-      dstdir_status=0-    else-      # Prefer dirname, but fall back on a substitute if dirname fails.-      dstdir=`-	(dirname "$dst") 2>/dev/null ||-	expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \-	     X"$dst" : 'X\(//\)[^/]' \| \-	     X"$dst" : 'X\(//\)$' \| \-	     X"$dst" : 'X\(/\)' \| . 2>/dev/null ||-	echo X"$dst" |-	    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{-		   s//\1/-		   q-		 }-		 /^X\(\/\/\)[^/].*/{-		   s//\1/-		   q-		 }-		 /^X\(\/\/\)$/{-		   s//\1/-		   q-		 }-		 /^X\(\/\).*/{-		   s//\1/-		   q-		 }-		 s/.*/./; q'-      `--      test -d "$dstdir"-      dstdir_status=$?-    fi-  fi--  obsolete_mkdir_used=false--  if test $dstdir_status != 0; then-    case $posix_mkdir in-      '')-	# Create intermediate dirs using mode 755 as modified by the umask.-	# This is like FreeBSD 'install' as of 1997-10-28.-	umask=`umask`-	case $stripcmd.$umask in-	  # Optimize common cases.-	  *[2367][2367]) mkdir_umask=$umask;;-	  .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;--	  *[0-7])-	    mkdir_umask=`expr $umask + 22 \-	      - $umask % 100 % 40 + $umask % 20 \-	      - $umask % 10 % 4 + $umask % 2-	    `;;-	  *) mkdir_umask=$umask,go-w;;-	esac--	# With -d, create the new directory with the user-specified mode.-	# Otherwise, rely on $mkdir_umask.-	if test -n "$dir_arg"; then-	  mkdir_mode=-m$mode-	else-	  mkdir_mode=-	fi--	posix_mkdir=false-	case $umask in-	  *[123567][0-7][0-7])-	    # POSIX mkdir -p sets u+wx bits regardless of umask, which-	    # is incompatible with FreeBSD 'install' when (umask & 300) != 0.-	    ;;-	  *)-	    tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$-	    trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0--	    if (umask $mkdir_umask &&-		exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1-	    then-	      if test -z "$dir_arg" || {-		   # Check for POSIX incompatibilities with -m.-		   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or-		   # other-writeable bit of parent directory when it shouldn't.-		   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.-		   ls_ld_tmpdir=`ls -ld "$tmpdir"`-		   case $ls_ld_tmpdir in-		     d????-?r-*) different_mode=700;;-		     d????-?--*) different_mode=755;;-		     *) false;;-		   esac &&-		   $mkdirprog -m$different_mode -p -- "$tmpdir" && {-		     ls_ld_tmpdir_1=`ls -ld "$tmpdir"`-		     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"-		   }-		 }-	      then posix_mkdir=:-	      fi-	      rmdir "$tmpdir/d" "$tmpdir"-	    else-	      # Remove any dirs left behind by ancient mkdir implementations.-	      rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null-	    fi-	    trap '' 0;;-	esac;;-    esac--    if-      $posix_mkdir && (-	umask $mkdir_umask &&-	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"-      )-    then :-    else--      # The umask is ridiculous, or mkdir does not conform to POSIX,-      # or it failed possibly due to a race condition.  Create the-      # directory the slow way, step by step, checking for races as we go.--      case $dstdir in-	/*) prefix='/';;-	-*) prefix='./';;-	*)  prefix='';;-      esac--      eval "$initialize_posix_glob"--      oIFS=$IFS-      IFS=/-      $posix_glob set -f-      set fnord $dstdir-      shift-      $posix_glob set +f-      IFS=$oIFS--      prefixes=--      for d-      do-	test -z "$d" && continue--	prefix=$prefix$d-	if test -d "$prefix"; then-	  prefixes=-	else-	  if $posix_mkdir; then-	    (umask=$mkdir_umask &&-	     $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break-	    # Don't fail if two instances are running concurrently.-	    test -d "$prefix" || exit 1-	  else-	    case $prefix in-	      *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;-	      *) qprefix=$prefix;;-	    esac-	    prefixes="$prefixes '$qprefix'"-	  fi-	fi-	prefix=$prefix/-      done--      if test -n "$prefixes"; then-	# Don't fail if two instances are running concurrently.-	(umask $mkdir_umask &&-	 eval "\$doit_exec \$mkdirprog $prefixes") ||-	  test -d "$dstdir" || exit 1-	obsolete_mkdir_used=true-      fi-    fi-  fi--  if test -n "$dir_arg"; then-    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&-    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||-      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1-  else--    # Make a couple of temp file names in the proper directory.-    dsttmp=$dstdir/_inst.$$_-    rmtmp=$dstdir/_rm.$$_--    # Trap to clean up those temp files at exit.-    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0--    # Copy the file name to the temp name.-    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&--    # and set any options; do chmod last to preserve setuid bits.-    #-    # If any of these fail, we abort the whole thing.  If we want to-    # ignore errors from any of these, just make sure not to ignore-    # errors from the above "$doit $cpprog $src $dsttmp" command.-    #-    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&-    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&-    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&--    # If -C, don't bother to copy if it wouldn't change the file.-    if $copy_on_change &&-       old=`LC_ALL=C ls -dlL "$dst"	2>/dev/null` &&-       new=`LC_ALL=C ls -dlL "$dsttmp"	2>/dev/null` &&--       eval "$initialize_posix_glob" &&-       $posix_glob set -f &&-       set X $old && old=:$2:$4:$5:$6 &&-       set X $new && new=:$2:$4:$5:$6 &&-       $posix_glob set +f &&--       test "$old" = "$new" &&-       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1-    then-      rm -f "$dsttmp"-    else-      # Rename the file to the real destination.-      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||--      # The rename failed, perhaps because mv can't rename something else-      # to itself, or perhaps because mv is so ancient that it does not-      # support -f.-      {-	# Now remove or move aside any old file at destination location.-	# We try this two ways since rm can't unlink itself on some-	# systems and the destination file might be busy for other-	# reasons.  In this case, the final cleanup might fail but the new-	# file should still install successfully.-	{-	  test ! -f "$dst" ||-	  $doit $rmcmd -f "$dst" 2>/dev/null ||-	  { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&-	    { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }-	  } ||-	  { echo "$0: cannot unlink or rename $dst" >&2-	    (exit 1); exit 1-	  }-	} &&--	# Now rename the file to the real destination.-	$doit $mvcmd "$dsttmp" "$dst"-      }-    fi || exit 1--    trap '' 0-  fi-done--# Local variables:-# eval: (add-hook 'write-file-hooks 'time-stamp)-# time-stamp-start: "scriptversion="-# time-stamp-format: "%:y-%02m-%02d.%02H"-# time-stamp-end: "$"-# End: