10 files changed, 50 insertions, 50 deletions

diff --git a/lib/Numeric/GSL/Differentiation.hs b/lib/Numeric/GSL/Differentiation.hs
index ab5eb50..d2a332c 100644
--- a/lib/Numeric/GSL/Differentiation.hs
+++ b/lib/Numeric/GSL/Differentiation.hs
@@ -48,7 +48,7 @@ derivGen c h f x = unsafePerformIO $ do
     freeHaskellFunPtr fp
     return result
 
-foreign import ccall "gsl-aux.h deriv" 
+foreign import ccall safe "gsl-aux.h deriv" 
  c_deriv :: CInt -> FunPtr (Double -> Ptr () -> Double) -> Double -> Double 
                     -> Ptr Double -> Ptr Double -> IO CInt
 
@@ -84,4 +84,4 @@ derivBackward = derivGen 2
 
 {- | conversion of Haskell functions into function pointers that can be used in the C side
 -}
-foreign import ccall "wrapper" mkfun:: (Double -> Ptr() -> Double) -> IO( FunPtr (Double -> Ptr() -> Double)) 
+foreign import ccall safe "wrapper" mkfun:: (Double -> Ptr() -> Double) -> IO( FunPtr (Double -> Ptr() -> Double)) 
diff --git a/lib/Numeric/GSL/Fitting.hs b/lib/Numeric/GSL/Fitting.hs
index 79db23f..6343b76 100644
--- a/lib/Numeric/GSL/Fitting.hs
+++ b/lib/Numeric/GSL/Fitting.hs
@@ -90,7 +90,7 @@ nlFitGen m f jac xiv epsabs epsrel maxit = unsafePerformIO $ do
     freeHaskellFunPtr jp
     return (subVector 2 p sol, path)
 
-foreign import ccall "nlfit"
+foreign import ccall safe "nlfit"
     c_nlfit:: CInt -> FunPtr TVV -> FunPtr TVM -> Double -> Double -> CInt -> CInt -> TVM
 
 -------------------------------------------------------
diff --git a/lib/Numeric/GSL/Fourier.hs b/lib/Numeric/GSL/Fourier.hs
index 71bc8a1..4ef19b3 100644
--- a/lib/Numeric/GSL/Fourier.hs
+++ b/lib/Numeric/GSL/Fourier.hs
@@ -30,7 +30,7 @@ genfft code v = unsafePerformIO $ do
     app2 (c_fft code) vec v vec r "fft"
     return r
 
-foreign import ccall "gsl-aux.h fft" c_fft ::  CInt -> TCVCV
+foreign import ccall unsafe "gsl-aux.h fft" c_fft ::  CInt -> TCVCV
 
 
 {- | Fast 1D Fourier transform of a 'Vector' @(@'Complex' 'Double'@)@ using /gsl_fft_complex_forward/. It uses the same scaling conventions as GNU Octave.
diff --git a/lib/Numeric/GSL/Integration.hs b/lib/Numeric/GSL/Integration.hs
index 2330fc6..defbf80 100644
--- a/lib/Numeric/GSL/Integration.hs
+++ b/lib/Numeric/GSL/Integration.hs
@@ -32,7 +32,7 @@ import System.IO.Unsafe(unsafePerformIO)
 
 {- | conversion of Haskell functions into function pointers that can be used in the C side
 -}
-foreign import ccall "wrapper" mkfun:: (Double -> Ptr() -> Double) -> IO( FunPtr (Double -> Ptr() -> Double)) 
+foreign import ccall safe "wrapper" mkfun:: (Double -> Ptr() -> Double) -> IO( FunPtr (Double -> Ptr() -> Double)) 
 
 --------------------------------------------------------------------
 {- | Numerical integration using /gsl_integration_qags/ (adaptive integration with singularities). For example:
@@ -63,7 +63,7 @@ integrateQAGS prec n f a b = unsafePerformIO $ do
     freeHaskellFunPtr fp
     return result
 
-foreign import ccall "gsl-aux.h integrate_qags" 
+foreign import ccall safe "gsl-aux.h integrate_qags" 
  c_integrate_qags :: FunPtr (Double-> Ptr() -> Double) -> Double -> Double -> Double -> CInt
                      -> Ptr Double -> Ptr Double -> IO CInt
 
@@ -94,7 +94,7 @@ integrateQNG prec f a b = unsafePerformIO $ do
     freeHaskellFunPtr fp
     return result
 
-foreign import ccall "gsl-aux.h integrate_qng" 
+foreign import ccall safe "gsl-aux.h integrate_qng" 
  c_integrate_qng :: FunPtr (Double-> Ptr() -> Double) -> Double -> Double -> Double 
                     -> Ptr Double -> Ptr Double -> IO CInt
 
@@ -126,7 +126,7 @@ integrateQAGI prec n f = unsafePerformIO $ do
     freeHaskellFunPtr fp
     return result
 
-foreign import ccall "gsl-aux.h integrate_qagi" 
+foreign import ccall safe "gsl-aux.h integrate_qagi" 
  c_integrate_qagi :: FunPtr (Double-> Ptr() -> Double) -> Double -> CInt
                      -> Ptr Double -> Ptr Double -> IO CInt
 
@@ -159,7 +159,7 @@ integrateQAGIU prec n f a = unsafePerformIO $ do
     freeHaskellFunPtr fp
     return result
 
-foreign import ccall "gsl-aux.h integrate_qagiu" 
+foreign import ccall safe "gsl-aux.h integrate_qagiu" 
  c_integrate_qagiu :: FunPtr (Double-> Ptr() -> Double) -> Double -> Double -> CInt
                      -> Ptr Double -> Ptr Double -> IO CInt
 
@@ -192,7 +192,7 @@ integrateQAGIL prec n f b = unsafePerformIO $ do
     freeHaskellFunPtr fp
     return result
 
-foreign import ccall "gsl-aux.h integrate_qagil" 
+foreign import ccall safe "gsl-aux.h integrate_qagil" 
  c_integrate_qagil :: FunPtr (Double-> Ptr() -> Double) -> Double -> Double -> CInt
                      -> Ptr Double -> Ptr Double -> IO CInt
 
diff --git a/lib/Numeric/GSL/Internal.hs b/lib/Numeric/GSL/Internal.hs
index 303e7e1..84417ce 100644
--- a/lib/Numeric/GSL/Internal.hs
+++ b/lib/Numeric/GSL/Internal.hs
@@ -26,14 +26,14 @@ iv f n p = f (createV (fromIntegral n) copy "iv") where
         return 0
 
 -- | conversion of Haskell functions into function pointers that can be used in the C side
-foreign import ccall "wrapper"
+foreign import ccall safe "wrapper"
     mkVecfun :: (CInt -> Ptr Double -> Double)
              -> IO( FunPtr (CInt -> Ptr Double -> Double))
 
-foreign import ccall "wrapper"
+foreign import ccall safe "wrapper"
     mkVecVecfun :: TVV -> IO (FunPtr TVV)
 
-foreign import ccall "wrapper"
+foreign import ccall safe "wrapper"
     mkDoubleVecVecfun :: (Double -> TVV) -> IO (FunPtr (Double -> TVV))
 
 aux_vTov :: (Vector Double -> Vector Double) -> TVV
@@ -46,10 +46,10 @@ aux_vTov f n p nr r = g where
     g = do unsafeWith v $ \p' -> copyArray r p' (fromIntegral nr)
            return 0
 
-foreign import ccall "wrapper"
+foreign import ccall safe "wrapper"
     mkVecMatfun :: TVM -> IO (FunPtr TVM)
 
-foreign import ccall "wrapper"
+foreign import ccall safe "wrapper"
     mkDoubleVecMatfun :: (Double -> TVM) -> IO (FunPtr (Double -> TVM))
 
 aux_vTom :: (Vector Double -> Matrix Double) -> TVM
diff --git a/lib/Numeric/GSL/Minimization.hs b/lib/Numeric/GSL/Minimization.hs
index 88acfac..af85135 100644
--- a/lib/Numeric/GSL/Minimization.hs
+++ b/lib/Numeric/GSL/Minimization.hs
@@ -122,7 +122,7 @@ minimizeV method eps maxit szv f xiv = unsafePerformIO $ do
     return (sol, path)
 
 
-foreign import ccall "gsl-aux.h minimize"
+foreign import ccall safe "gsl-aux.h minimize"
     c_minimize:: CInt -> FunPtr (CInt -> Ptr Double -> Double) -> Double -> CInt -> TVVM
 
 ----------------------------------------------------------------------------------
@@ -179,7 +179,7 @@ minimizeVD method eps maxit istep tol f df xiv = unsafePerformIO $ do
     freeHaskellFunPtr dfp
     return (sol,path)
 
-foreign import ccall "gsl-aux.h minimizeD"
+foreign import ccall safe "gsl-aux.h minimizeD"
     c_minimizeD :: CInt
                 -> FunPtr (CInt -> Ptr Double -> Double)
                 -> FunPtr TVV
diff --git a/lib/Numeric/GSL/ODE.hs b/lib/Numeric/GSL/ODE.hs
index c243f4b..3994210 100644
--- a/lib/Numeric/GSL/ODE.hs
+++ b/lib/Numeric/GSL/ODE.hs
@@ -116,7 +116,7 @@ odeSolveV' method mbjac h epsAbs epsRel f  xiv ts = unsafePerformIO $ do
     freeHaskellFunPtr fp
     return sol
 
-foreign import ccall "ode"
+foreign import ccall safe "ode"
     ode_c :: CInt -> Double -> Double -> Double -> FunPtr (Double -> TVV) -> FunPtr (Double -> TVM) -> TVVM
 
 -------------------------------------------------------
diff --git a/lib/Numeric/GSL/Polynomials.hs b/lib/Numeric/GSL/Polynomials.hs
index b21b1b6..694c003 100644
--- a/lib/Numeric/GSL/Polynomials.hs
+++ b/lib/Numeric/GSL/Polynomials.hs
@@ -55,4 +55,4 @@ polySolve' v | dim v > 1 = unsafePerformIO $ do
     return r
              | otherwise = error "polySolve on a polynomial of degree zero"
 
-foreign import ccall "gsl-aux.h polySolve" c_polySolve:: TVCV
+foreign import ccall unsafe "gsl-aux.h polySolve" c_polySolve:: TVCV
diff --git a/lib/Numeric/GSL/Root.hs b/lib/Numeric/GSL/Root.hs
index 41f7fb3..cd2982a 100644
--- a/lib/Numeric/GSL/Root.hs
+++ b/lib/Numeric/GSL/Root.hs
@@ -91,7 +91,7 @@ rootGen m f xi epsabs maxit = unsafePerformIO $ do
     return (take n $ drop 1 sol, path)
 
 
-foreign import ccall "root"
+foreign import ccall safe "root"
     c_root:: CInt -> FunPtr TVV -> Double -> CInt -> TVM
 
 -------------------------------------------------------------------------
@@ -130,7 +130,7 @@ rootJGen m f jac xi epsabs maxit = unsafePerformIO $ do
     return (take n $ drop 1 sol, path)
 
 
-foreign import ccall "rootj"
+foreign import ccall safe "rootj"
     c_rootj:: CInt -> FunPtr TVV -> FunPtr TVM -> Double -> CInt -> TVM
 
 -------------------------------------------------------
diff --git a/lib/Numeric/GSL/Vector.hs b/lib/Numeric/GSL/Vector.hs
index b8c6d04..db34041 100644
--- a/lib/Numeric/GSL/Vector.hs
+++ b/lib/Numeric/GSL/Vector.hs
@@ -109,10 +109,10 @@ sumC x = unsafePerformIO $ do
            app2 c_sumC vec x vec r "sumC"
            return $ r @> 0
 
-foreign import ccall safe "gsl-aux.h sumF" c_sumF :: TFF
-foreign import ccall safe "gsl-aux.h sumR" c_sumR :: TVV
-foreign import ccall safe "gsl-aux.h sumQ" c_sumQ :: TQVQV
-foreign import ccall safe "gsl-aux.h sumC" c_sumC :: TCVCV
+foreign import ccall unsafe "gsl-aux.h sumF" c_sumF :: TFF
+foreign import ccall unsafe "gsl-aux.h sumR" c_sumR :: TVV
+foreign import ccall unsafe "gsl-aux.h sumQ" c_sumQ :: TQVQV
+foreign import ccall unsafe "gsl-aux.h sumC" c_sumC :: TCVCV
 
 -- | product of elements
 prodF :: Vector Float -> Float
@@ -142,10 +142,10 @@ prodC x = unsafePerformIO $ do
            app2 c_prodC vec x vec r "prodC"
            return $ r @> 0
 
-foreign import ccall safe "gsl-aux.h prodF" c_prodF :: TFF
-foreign import ccall safe "gsl-aux.h prodR" c_prodR :: TVV
-foreign import ccall safe "gsl-aux.h prodQ" c_prodQ :: TQVQV
-foreign import ccall safe "gsl-aux.h prodC" c_prodC :: TCVCV
+foreign import ccall unsafe "gsl-aux.h prodF" c_prodF :: TFF
+foreign import ccall unsafe "gsl-aux.h prodR" c_prodR :: TVV
+foreign import ccall unsafe "gsl-aux.h prodQ" c_prodQ :: TQVQV
+foreign import ccall unsafe "gsl-aux.h prodC" c_prodC :: TCVCV
 
 -- | dot product
 dotF :: Vector Float -> Vector Float -> Float
@@ -175,10 +175,10 @@ dotC x y = unsafePerformIO $ do
            app3 c_dotC vec x vec y vec r "dotC"
            return $ r @> 0
 
-foreign import ccall safe "gsl-aux.h dotF" c_dotF :: TFFF
-foreign import ccall safe "gsl-aux.h dotR" c_dotR :: TVVV
-foreign import ccall safe "gsl-aux.h dotQ" c_dotQ :: TQVQVQV
-foreign import ccall safe "gsl-aux.h dotC" c_dotC :: TCVCVCV
+foreign import ccall unsafe "gsl-aux.h dotF" c_dotF :: TFFF
+foreign import ccall unsafe "gsl-aux.h dotR" c_dotR :: TVVV
+foreign import ccall unsafe "gsl-aux.h dotQ" c_dotQ :: TQVQVQV
+foreign import ccall unsafe "gsl-aux.h dotC" c_dotC :: TCVCVCV
 
 ------------------------------------------------------------------
 
@@ -210,25 +210,25 @@ vectorZipAux fun code u v = unsafePerformIO $ do
 toScalarR :: FunCodeS -> Vector Double -> Double
 toScalarR oper =  toScalarAux c_toScalarR (fromei oper)
 
-foreign import ccall safe "gsl-aux.h toScalarR" c_toScalarR :: CInt -> TVV
+foreign import ccall unsafe "gsl-aux.h toScalarR" c_toScalarR :: CInt -> TVV
 
 -- | obtains different functions of a vector: norm1, norm2, max, min, posmax, posmin, etc.
 toScalarF :: FunCodeS -> Vector Float -> Float
 toScalarF oper =  toScalarAux c_toScalarF (fromei oper)
 
-foreign import ccall safe "gsl-aux.h toScalarF" c_toScalarF :: CInt -> TFF
+foreign import ccall unsafe "gsl-aux.h toScalarF" c_toScalarF :: CInt -> TFF
 
 -- | obtains different functions of a vector: only norm1, norm2
 toScalarC :: FunCodeS -> Vector (Complex Double) -> Double
 toScalarC oper =  toScalarAux c_toScalarC (fromei oper)
 
-foreign import ccall safe "gsl-aux.h toScalarC" c_toScalarC :: CInt -> TCVV
+foreign import ccall unsafe "gsl-aux.h toScalarC" c_toScalarC :: CInt -> TCVV
 
 -- | obtains different functions of a vector: only norm1, norm2
 toScalarQ :: FunCodeS -> Vector (Complex Float) -> Float
 toScalarQ oper =  toScalarAux c_toScalarQ (fromei oper)
 
-foreign import ccall safe "gsl-aux.h toScalarQ" c_toScalarQ :: CInt -> TQVF
+foreign import ccall unsafe "gsl-aux.h toScalarQ" c_toScalarQ :: CInt -> TQVF
 
 ------------------------------------------------------------------
 
@@ -236,25 +236,25 @@ foreign import ccall safe "gsl-aux.h toScalarQ" c_toScalarQ :: CInt -> TQVF
 vectorMapR :: FunCodeV -> Vector Double -> Vector Double
 vectorMapR = vectorMapAux c_vectorMapR
 
-foreign import ccall safe "gsl-aux.h mapR" c_vectorMapR :: CInt -> TVV
+foreign import ccall unsafe "gsl-aux.h mapR" c_vectorMapR :: CInt -> TVV
 
 -- | map of complex vectors with given function
 vectorMapC :: FunCodeV -> Vector (Complex Double) -> Vector (Complex Double)
 vectorMapC oper = vectorMapAux c_vectorMapC (fromei oper)
 
-foreign import ccall safe "gsl-aux.h mapC" c_vectorMapC :: CInt -> TCVCV
+foreign import ccall unsafe "gsl-aux.h mapC" c_vectorMapC :: CInt -> TCVCV
 
 -- | map of real vectors with given function
 vectorMapF :: FunCodeV -> Vector Float -> Vector Float
 vectorMapF = vectorMapAux c_vectorMapF
 
-foreign import ccall safe "gsl-aux.h mapF" c_vectorMapF :: CInt -> TFF
+foreign import ccall unsafe "gsl-aux.h mapF" c_vectorMapF :: CInt -> TFF
 
 -- | map of real vectors with given function
 vectorMapQ :: FunCodeV -> Vector (Complex Float) -> Vector (Complex Float)
 vectorMapQ = vectorMapAux c_vectorMapQ
 
-foreign import ccall safe "gsl-aux.h mapQ" c_vectorMapQ :: CInt -> TQVQV
+foreign import ccall unsafe "gsl-aux.h mapQ" c_vectorMapQ :: CInt -> TQVQV
 
 -------------------------------------------------------------------
 
@@ -262,25 +262,25 @@ foreign import ccall safe "gsl-aux.h mapQ" c_vectorMapQ :: CInt -> TQVQV
 vectorMapValR :: FunCodeSV -> Double -> Vector Double -> Vector Double
 vectorMapValR oper = vectorMapValAux c_vectorMapValR (fromei oper)
 
-foreign import ccall safe "gsl-aux.h mapValR" c_vectorMapValR :: CInt -> Ptr Double -> TVV
+foreign import ccall unsafe "gsl-aux.h mapValR" c_vectorMapValR :: CInt -> Ptr Double -> TVV
 
 -- | map of complex vectors with given function
 vectorMapValC :: FunCodeSV -> Complex Double -> Vector (Complex Double) -> Vector (Complex Double)
 vectorMapValC = vectorMapValAux c_vectorMapValC
 
-foreign import ccall safe "gsl-aux.h mapValC" c_vectorMapValC :: CInt -> Ptr (Complex Double) -> TCVCV
+foreign import ccall unsafe "gsl-aux.h mapValC" c_vectorMapValC :: CInt -> Ptr (Complex Double) -> TCVCV
 
 -- | map of real vectors with given function
 vectorMapValF :: FunCodeSV -> Float -> Vector Float -> Vector Float
 vectorMapValF oper = vectorMapValAux c_vectorMapValF (fromei oper)
 
-foreign import ccall safe "gsl-aux.h mapValF" c_vectorMapValF :: CInt -> Ptr Float -> TFF
+foreign import ccall unsafe "gsl-aux.h mapValF" c_vectorMapValF :: CInt -> Ptr Float -> TFF
 
 -- | map of complex vectors with given function
 vectorMapValQ :: FunCodeSV -> Complex Float -> Vector (Complex Float) -> Vector (Complex Float)
 vectorMapValQ oper = vectorMapValAux c_vectorMapValQ (fromei oper)
 
-foreign import ccall safe "gsl-aux.h mapValQ" c_vectorMapValQ :: CInt -> Ptr (Complex Float) -> TQVQV
+foreign import ccall unsafe "gsl-aux.h mapValQ" c_vectorMapValQ :: CInt -> Ptr (Complex Float) -> TQVQV
 
 -------------------------------------------------------------------
 
@@ -288,25 +288,25 @@ foreign import ccall safe "gsl-aux.h mapValQ" c_vectorMapValQ :: CInt -> Ptr (Co
 vectorZipR :: FunCodeVV -> Vector Double -> Vector Double -> Vector Double
 vectorZipR = vectorZipAux c_vectorZipR
 
-foreign import ccall safe "gsl-aux.h zipR" c_vectorZipR :: CInt -> TVVV
+foreign import ccall unsafe "gsl-aux.h zipR" c_vectorZipR :: CInt -> TVVV
 
 -- | elementwise operation on complex vectors
 vectorZipC :: FunCodeVV -> Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double)
 vectorZipC = vectorZipAux c_vectorZipC
 
-foreign import ccall safe "gsl-aux.h zipC" c_vectorZipC :: CInt -> TCVCVCV
+foreign import ccall unsafe "gsl-aux.h zipC" c_vectorZipC :: CInt -> TCVCVCV
 
 -- | elementwise operation on real vectors
 vectorZipF :: FunCodeVV -> Vector Float -> Vector Float -> Vector Float
 vectorZipF = vectorZipAux c_vectorZipF
 
-foreign import ccall safe "gsl-aux.h zipF" c_vectorZipF :: CInt -> TFFF
+foreign import ccall unsafe "gsl-aux.h zipF" c_vectorZipF :: CInt -> TFFF
 
 -- | elementwise operation on complex vectors
 vectorZipQ :: FunCodeVV -> Vector (Complex Float) -> Vector (Complex Float) -> Vector (Complex Float)
 vectorZipQ = vectorZipAux c_vectorZipQ
 
-foreign import ccall safe "gsl-aux.h zipQ" c_vectorZipQ :: CInt -> TQVQVQV
+foreign import ccall unsafe "gsl-aux.h zipQ" c_vectorZipQ :: CInt -> TQVQVQV
 
 -----------------------------------------------------------------------
 
@@ -324,4 +324,4 @@ randomVector seed dist n = unsafePerformIO $ do
     app1 (c_random_vector (fi seed) ((fi.fromEnum) dist)) vec r "randomVector"
     return r
 
-foreign import ccall safe "random_vector" c_random_vector :: CInt -> CInt -> TV
+foreign import ccall unsafe "random_vector" c_random_vector :: CInt -> CInt -> TV