matlab (empty) → 0.1

raw patch · 29 files changed

+5969/−0 lines, 29 filesdep +Cabaldep +arraydep +basebuild-type:Customsetup-changed

Dependencies added: Cabal, array, base, filepath, unix

Files

• Foreign/Matlab.hs +23/−0
• Foreign/Matlab/Array.hsc +454/−0
• Foreign/Matlab/Array/Able.hs +53/−0
• Foreign/Matlab/Array/Auto.hs +33/−0
• Foreign/Matlab/Array/IMX.hs +315/−0
• Foreign/Matlab/Array/MArray.hs +38/−0
• Foreign/Matlab/Config.hs +1/−0
• Foreign/Matlab/Config.hs.in +11/−0
• Foreign/Matlab/Engine.hsc +87/−0
• Foreign/Matlab/Internal.hsc +215/−0
• Foreign/Matlab/MAT.hsc +118/−0
• Foreign/Matlab/Runtime.hsc +139/−0
• Foreign/Matlab/Runtime/Generic.hs +80/−0
• Foreign/Matlab/Types.hs +155/−0
• Foreign/Matlab/Util.hs +59/−0
• Setup.hs +59/−0
• configure +3978/−0
• matlab.buildinfo.in +3/−0
• matlab.cabal +43/−0
• src/Makefile.in +19/−0
• src/hsc_sym.h +2/−0
• src/hsmatlab.c +6/−0
• src/hsmatlab.m +1/−0
• test/Makefile.in +22/−0
• test/engine.hs +12/−0
• test/generic.hs +13/−0
• test/hsmli.hs +15/−0
• test/mtest.m +2/−0
• test/runtime.hs +13/−0

@@ -0,0 +1,23 @@+{-# OPTIONS_GHC -fno-implicit-prelude #-}++{-|+  Bundles Matlab data structure and general-purpose routines.+-}++module Foreign.Matlab+  ( module Foreign.Matlab.Types+  , module Foreign.Matlab.Array+  , module Foreign.Matlab.Array.Auto+  --, module Foreign.Matlab.Array.MArray+  , module Foreign.Matlab.Array.IMX+  , module Foreign.Matlab.Array.Able+  , module Foreign.Matlab.MAT+  ) where++import Foreign.Matlab.Types+import Foreign.Matlab.Array+import Foreign.Matlab.Array.Auto+--import Foreign.Matlab.Array.MArray+import Foreign.Matlab.Array.IMX+import Foreign.Matlab.Array.Able+import Foreign.Matlab.MAT

@@ -0,0 +1,454 @@+{-|+  Array access, including cell arrays and structures.++  Functions here are primarily thin wrappers to the underlying Matlab functions, and the same memory-management semantics hold.+  In particular, created arrays must be freed, 'copyMXArray' and 'freeMXArray' are deep operations, other set operations do not make copies.+-}++module Foreign.Matlab.Array (+    -- * Array manipulation+    anyMXArray,+    MNullArray, castMNull,+    mxArrayClass,+    mxArrayIsComplex,+    mxArraySize,+    mxArraySetSize,+    mxArrayLength,+    freeMXArray,+    copyMXArray,+    mIndexOffset,++    -- * Array element access+    MXArrayComponent,+    castMXArray,+    -- |raw array element access+    mxArrayGetOffset, mxArraySetOffset,+    -- |raw array list access+    mxArrayGetOffsetList, mxArraySetOffsetList,+    -- |array element access+    mxArrayGet, mxArraySet,+    -- |array list access+    mxArrayGetList, mxArraySetList,+    mxScalarGet, isMXScalar,+    createMXArray, createMXScalar,+    createColVector, createRowVector,+    mxArrayGetAll, mxArraySetAll,+    +    -- * Struct access+    -- |Structs in Matlab are always arrays, and so can be accessed using most array accessors.+    -- |However, the modification functions such as 'mxArraySet' are not implemented because they could disrupt field data in the entire struct array, and so some specialized functions are necessary.+    MStructArray,+    createStruct,+    mStructFields,+    mStructGet, mStructSet,+    mStructSetFields,+    mStructAddField, mStructRemoveField,++    -- ** Object access+    -- |Some structs are also validated (blessed) user objects.+    mObjectGetClass, mObjectSetClass+  ) where++import Control.Monad+import Foreign+import Foreign.C.String+import Foreign.C.Types+import Data.Complex+import Foreign.Matlab.Util+import Foreign.Matlab.Internal+import Foreign.Matlab.Types++#include <matrix.h>++-- |(Un)cast an array to a generic type.+anyMXArray :: MXArray a -> MAnyArray+anyMXArray a = unsafeCastMXArray a++-- |A NULL (empty) array+type MNullArray = MXArray MNull+-- |Safely cast a generic array to a NULL array, or return Nothing if the array is not NULL+castMNull :: MAnyArray -> MIO (Maybe MNullArray)+castMNull a +  | isMNull a = return $ Just (unsafeCastMXArray a)+  | otherwise = return Nothing++foreign import ccall unsafe mxGetClassID :: MXArrayPtr -> IO MXClassID+-- |Return the representation of the type of the elements of an array+mxArrayClass :: MXArray a -> IO MXClass+mxArrayClass a+  | isMNull a = return $ MXClassNull+  | otherwise = withMXArray a mxGetClassID >.= mx2hs++ndims :: MWSize -> Ptr MWSize -> IO MSize+ndims n s = map ii =.< peekArray (ii n) s+--nsubs = ndims++withNSubs :: With MSubs (MWSize, Ptr MWSize) (IO a)+withNSubs l f = withArrayLen (map ii l) (\l a -> f (ii l, a))+withNDims :: With MSize (MWSize, Ptr MWSize) (IO a)+withNDims = withNSubs . realMSize++foreign import ccall unsafe mxGetNumberOfDimensions :: MXArrayPtr -> IO MWSize+foreign import ccall unsafe mxGetDimensions :: MXArrayPtr -> IO (Ptr MWSize)+-- |Get the size (dimensions) of an array+mxArraySize :: MXArray a -> MIO MSize+mxArraySize a = withMXArray a $ \a -> do+  n <- mxGetNumberOfDimensions a+  s <- mxGetDimensions a+  ndims n s++foreign import ccall unsafe mxSetDimensions :: MXArrayPtr -> Ptr MWSize -> MWSize -> IO CInt+-- |Set dimension array and number of dimensions+mxArraySetSize :: MXArray a -> MSize -> IO ()+mxArraySetSize a s = do+  r <- withMXArray a (\a -> withNDims s (\(nd,d) -> mxSetDimensions a d nd))+  when (r /= 0) $ fail "mxArraySetSize"++foreign import ccall unsafe mxGetNumberOfElements :: MXArrayPtr -> IO CSize+mxArrayLength :: MXArray a -> MIO Int+mxArrayLength a = ii =.< withMXArray a mxGetNumberOfElements++foreign import ccall unsafe mxCalcSingleSubscript :: MXArrayPtr -> MWSize -> Ptr MWIndex -> IO MWIndex+-- |Convert an array subscript into an offset+mIndexOffset :: MXArray a -> MIndex -> MIO Int+mIndexOffset _ (MSubs []) = return 0+mIndexOffset _ (MSubs [i]) = return i+mIndexOffset a (MSubs i) = ii =.< withMXArray a (withNSubs i . uncurry . mxCalcSingleSubscript)++foreign import ccall unsafe mxDuplicateArray :: MXArrayPtr -> IO MXArrayPtr+-- |Make a deep copy of an array+copyMXArray :: MXArray a -> MIO (MXArray a)+copyMXArray a = withMXArray a mxDuplicateArray >>= mkMXArray++foreign import ccall unsafe mxDestroyArray :: MXArrayPtr -> IO ()+-- |Destroy an array and all of its contents.+freeMXArray :: MXArray a -> MIO ()+freeMXArray a = withMXArray a mxDestroyArray++-- |The class of standardly typeable array elements+class MXArrayComponent a where+  -- |Determine whether the given array is of the correct type+  isMXArray :: MXArray a -> MIO Bool+  -- |Create an array and initialize all its data elements to some default value, usually 0 or []+  createMXArray :: MSize -> MIO (MXArray a)++  -- |Determine if an array is singleton. Equivalent to+  --+  -- >  liftM (all (1 ==)) . mxArraySize+  isMXScalar :: MXArray a -> MIO Bool++  mxArrayGetOffset :: MXArray a -> Int -> MIO a+  mxArraySetOffset :: MXArray a -> Int -> a -> MIO ()++  mxArrayGetOffsetList :: MXArray a -> Int -> Int -> MIO [a]+  mxArraySetOffsetList :: MXArray a -> Int -> [a] -> MIO ()++  -- |Get the value of the first data element in an array or, more specifically, the value that the array will be interpreted as in scalar context+  mxScalarGet :: MXArray a -> MIO a++  -- |Create a singleton (scalar) array having the specified value+  createMXScalar :: a -> MIO (MXArray a)+  -- |Create a column vector from the given list.+  createColVector :: [a] -> MIO (MXArray a)+  -- |Create a row vector from the given list.+  createRowVector :: [a] -> MIO (MXArray a)++  isMXArray _ = return False+  isMXScalar a = liftM2 (&&) (isMXArray a) (all (1 ==) =.< mxArraySize a)++  mxArrayGetOffsetList a o n = mapM (mxArrayGetOffset a) [o..o+n-1]+  mxArraySetOffsetList a o = zipWithM_ (mxArraySetOffset a . (o+)) [0..]++  mxScalarGet a = mxArrayGetOffset a 0++  createMXScalar x = do+    a <- createMXArray [1]+    mxArraySetOffset a 0 x+    return a+  createRowVector l = do+    a <- createMXArray [1,length l]+    mxArraySetOffsetList a 0 l+    return a+  createColVector l = do+    a <- createMXArray [length l]+    mxArraySetOffsetList a 0 l+    return a++-- |Get the value of the specified array element.  Does not check bounds.+mxArrayGet :: MXArrayComponent a => MXArray a -> MIndex -> MIO a+mxArrayGet a i = mIndexOffset a i >>= mxArrayGetOffset a+-- |Set an element in an array to the specified value.  Does not check bounds.+mxArraySet :: MXArrayComponent a => MXArray a -> MIndex -> a -> MIO ()+mxArraySet a i v = do+  o <- mIndexOffset a i+  mxArraySetOffset a o v++-- |@'mxArrayGetList' a i n@ gets the sequential list of @n@ items from array @a@ starting at index @i@.  Does not check bounds.+mxArrayGetList :: MXArrayComponent a => MXArray a -> MIndex -> Int -> MIO [a]+mxArrayGetList a i n = do+  o <- mIndexOffset a i+  n <- if n == -1 then subtract o =.< mxArrayLength a else return n+  mxArrayGetOffsetList a o n+-- |@'mxArraySetList' a i l@ sets the sequential items in array @a@ starting at index @i@ to @l@.  Does not check bounds.+mxArraySetList :: MXArrayComponent a => MXArray a -> MIndex -> [a] -> MIO ()+mxArraySetList a i l = do+  o <- mIndexOffset a i+  mxArraySetOffsetList a o l++-- |Get a flat list of all elements in the array.+mxArrayGetAll :: MXArrayComponent a => MXArray a -> IO [a]+mxArrayGetAll a = mxArrayGetList a mStart (-1)++-- |Set a flat list of all elements in the array.+mxArraySetAll :: MXArrayComponent a => MXArray a -> [a] -> IO ()+mxArraySetAll a = mxArraySetList a mStart++-- |Safely cast a generic array to a type, or return Nothing if the array does not have the proper type+castMXArray :: forall a. MXArrayComponent a => MAnyArray -> MIO (Maybe (MXArray a))+castMXArray a+  | isMNull a = return Nothing+  | otherwise = do+      y <- isMXArray b+      return $ if y then Just b else Nothing+      where+	b :: MXArray a+	b = unsafeCastMXArray a++foreign import ccall unsafe mxGetData :: MXArrayPtr -> IO (Ptr a)++class (MXArrayComponent a, MType mx a, Storable mx) => MXArrayData mx a where+  withArrayData :: MXArray a -> (Ptr mx -> IO b) -> IO b+  withArrayDataOff :: MXArray a -> Int -> (Ptr mx -> IO b) -> IO b+  arrayDataGet :: MXArray a -> Int -> IO a+  arrayDataSet :: MXArray a -> Int -> a -> IO ()++  arrayDataGetList :: MXArray a -> Int -> Int -> IO [a]+  arrayDataSetList :: MXArray a -> Int -> [a] -> IO ()++  withArrayData a f = withMXArray a (mxGetData >=> f)+  withArrayDataOff a o f = withArrayData a (\p -> f (advancePtr p o))+  arrayDataGet a o   = withArrayDataOff a o (mx2hs .=< peek)+  arrayDataSet a o v = withArrayDataOff a o (\p -> poke p (hs2mx v))+  arrayDataGetList a o n = withArrayDataOff a o (map mx2hs .=< peekArray n)+  arrayDataSetList a o l = withArrayDataOff a o (\p -> pokeArray p (map hs2mx l))+#let arrayDataComponent = "\+mxArrayGetOffset = arrayDataGet ;\+mxArraySetOffset = arrayDataSet ;\+mxArrayGetOffsetList = arrayDataGetList ;\+mxArraySetOffsetList = arrayDataSetList\+"+--"++foreign import ccall unsafe mxIsLogical :: MXArrayPtr -> IO CBool+foreign import ccall unsafe mxCreateLogicalArray :: MWSize -> Ptr MWSize -> IO MXArrayPtr+foreign import ccall unsafe mxGetLogicals :: MXArrayPtr -> IO (Ptr MXLogical)+foreign import ccall unsafe mxCreateLogicalScalar :: CBool -> IO MXArrayPtr+foreign import ccall unsafe mxIsLogicalScalar :: MXArrayPtr -> IO CBool+foreign import ccall unsafe mxIsLogicalScalarTrue :: MXArrayPtr -> IO CBool+instance MXArrayComponent MLogical where+  isMXArray a = boolC =.< withMXArray a mxIsLogical+  createMXArray s = withNDims s (uncurry mxCreateLogicalArray) >>= mkMXArray+  createMXScalar = mxCreateLogicalScalar . cBool >=> mkMXArray+  isMXScalar a = boolC =.< withMXArray a mxIsLogicalScalar+  mxScalarGet a = boolC =.< withMXArray a mxIsLogicalScalarTrue+  #arrayDataComponent+instance MXArrayData MXLogical MLogical where+  withArrayData a f = withMXArray a (mxGetLogicals >=> f)++foreign import ccall unsafe mxIsChar :: MXArrayPtr -> IO CBool+foreign import ccall unsafe mxCreateCharArray :: MWSize -> Ptr MWSize -> IO MXArrayPtr+foreign import ccall unsafe mxGetChars :: MXArrayPtr -> IO (Ptr MXChar)+foreign import ccall unsafe mxCreateStringFromNChars :: CString -> MWSize -> IO MXArrayPtr+instance MXArrayComponent MChar where+  isMXArray a = boolC =.< withMXArray a mxIsChar+  createMXArray s = withNDims s (uncurry mxCreateCharArray) >>= mkMXArray+  createRowVector s = +    mkMXArray =<< withCStringLen s (\(s,n) -> mxCreateStringFromNChars s (ii n))+  #arrayDataComponent+instance MXArrayData MXChar MChar where+  withArrayData a f = withMXArray a (mxGetChars >=> f)++foreign import ccall unsafe mxCreateNumericArray :: MWSize -> Ptr MWSize -> MXClassID -> (#type mxComplexity) -> IO MXArrayPtr+createNumericArray :: MXClass -> Bool -> MWSize -> Ptr MWSize -> IO MXArrayPtr+createNumericArray t c n s = mxCreateNumericArray n s (hs2mx t) (if c then (#const mxCOMPLEX) else (#const mxREAL))++#let numarray t = "\+foreign import ccall unsafe mxIs%1$s :: MXArrayPtr -> IO CBool\n\+instance MXArrayComponent M%1$s where\n\+  isMXArray a = boolC =.< withMXArray a mxIs%1$s\n\+  createMXArray s = withNDims s (uncurry $ createNumericArray (mxClassOf (undefined :: M%1$s)) False) >>= mkMXArray\n\+  \+mxArrayGetOffset = arrayDataGet ;\+mxArraySetOffset = arrayDataSet ;\+mxArrayGetOffsetList = arrayDataGetList ;\+mxArraySetOffsetList = arrayDataSetList\+  \n\+instance MXArrayData MX%1$s M%1$s\+", #t+--"++foreign import ccall unsafe mxIsDouble :: MXArrayPtr -> IO CBool+foreign import ccall unsafe mxCreateDoubleScalar :: MXDouble -> IO MXArrayPtr+foreign import ccall unsafe mxGetScalar :: MXArrayPtr -> IO MXDouble+instance MXArrayComponent MDouble where+  isMXArray a = boolC =.< withMXArray a mxIsDouble+  createMXScalar = mxCreateDoubleScalar . hs2mx >=> mkMXArray+  mxScalarGet a = withMXArray a mxGetScalar+  createMXArray s = withNDims s (uncurry $ createNumericArray (mxClassOf (undefined :: Double)) False) >>= mkMXArray+  #arrayDataComponent+instance MXArrayData MXDouble MDouble++#numarray Single+#numarray Int8+#numarray Int16+#numarray Int32+#numarray Int64+#numarray Uint8+#numarray Uint16+#numarray Uint32+#numarray Uint64+++foreign import ccall unsafe mxIsCell :: MXArrayPtr -> IO CBool+foreign import ccall unsafe mxCreateCellArray :: MWSize -> Ptr MWSize -> IO MXArrayPtr+foreign import ccall unsafe mxGetCell :: MXArrayPtr -> MWIndex -> IO MXArrayPtr+foreign import ccall unsafe mxSetCell :: MXArrayPtr -> MWIndex -> MXArrayPtr -> IO ()+instance MXArrayComponent MCell where+  isMXArray a = boolC =.< withMXArray a mxIsCell+  createMXArray s = withNDims s (uncurry mxCreateCellArray) >>= mkMXArray+  -- Get a the specified cell element (not a copy).+  mxArrayGetOffset a o = withMXArray a (\a -> mxGetCell a (ii o) >>= mkMXArray >.= MCell)+  -- Set an element in a cell array to the specified value. The cell takes ownership of the array: and no copy is made. Any existing value should be freed first.+  mxArraySetOffset a o (MCell v) = withMXArray a (\a -> withMXArray v (mxSetCell a (ii o)))++-- |A (array of) structs+type MStructArray = MXArray MStruct++foreign import ccall unsafe mxIsStruct :: MXArrayPtr -> IO CBool+foreign import ccall unsafe mxIsObject :: MXArrayPtr -> IO CBool++foreign import ccall unsafe mxCreateStructArray :: MWSize -> Ptr MWSize -> CInt -> Ptr CString -> IO MXArrayPtr+-- |Create an N-Dimensional structure array having the specified fields; initialize all values to 'MNullArray'+createStruct :: MSize -> [String] -> MIO MStructArray+createStruct s f = +  withNDims s (\(nd,d) -> +    mapWithArrayLen withCString f (\(f,nf) ->+      mxCreateStructArray nd d (ii nf) f))+  >>= mkMXArray++foreign import ccall unsafe mxGetNumberOfFields :: MXArrayPtr -> IO CInt+foreign import ccall unsafe mxGetFieldNameByNumber :: MXArrayPtr -> CInt -> IO CString+foreign import ccall unsafe mxGetFieldNumber :: MXArrayPtr -> CString -> IO CInt+-- |Get the names of the fields+mStructFields :: MStructArray -> MIO [String]+mStructFields a = withMXArray a $ \a -> do+  n <- mxGetNumberOfFields a+  forM [0..pred n] (mxGetFieldNameByNumber a >=> peekCString)++foreign import ccall unsafe mxGetField :: MXArrayPtr -> MWIndex -> CString -> IO MXArrayPtr+foreign import ccall unsafe mxSetField :: MXArrayPtr -> MWIndex -> CString -> MXArrayPtr -> IO ()+foreign import ccall unsafe mxGetFieldByNumber :: MXArrayPtr -> MWIndex -> CInt -> IO MXArrayPtr+foreign import ccall unsafe mxSetFieldByNumber :: MXArrayPtr -> MWIndex -> CInt -> MXArrayPtr -> IO ()++-- |Return the contents of the named field for the given element. Returns 'MNullArray' on no such field or if the field itself is NULL+mStructGet :: MStructArray -> MIndex -> String -> MIO MAnyArray+-- |Sets the contents of the named field for the given element. The input is stored in the array -- no copy is made.+mStructSet :: MStructArray -> MIndex -> String -> MXArray a -> MIO ()+mStructGet a i f = do+  o <- mIndexOffset a i+  withMXArray a (\a -> withCString f (mxGetField a (ii o) >=> mkMXArray))+mStructSet a i f v = do+  o <- mIndexOffset a i+  withMXArray a (\a -> withCString f (withMXArray v . mxSetField a (ii o)))++foreign import ccall unsafe mxAddField :: MXArrayPtr -> CString -> IO CInt+foreign import ccall unsafe mxRemoveField :: MXArrayPtr -> CInt -> IO ()+-- |Add a field to a structure array.+mStructAddField :: MStructArray -> String -> MIO ()+-- |Remove a field from a structure array. Does nothing if no such field exists.+mStructRemoveField :: MStructArray -> String -> MIO ()+mStructAddField a f = do+  i <- withMXArray a (withCString f . mxAddField)+  when (i < 0) $ fail "mxAddField"+mStructRemoveField a f = withMXArray a $ \a -> do+  i <- withCString f (mxGetFieldNumber a)+  if i < 0+    then fail "mxRemoveField"+    else mxRemoveField a i++structGetOffsetFields :: MStructArray -> [String] -> Int -> IO MStruct+structGetOffsetFields a f o =+  MStruct =.< withMXArray a (\a -> zipWithM (\f -> ((,) f) .=< (mxGetFieldByNumber a (ii o) >=> mkMXArray)) f [0..])++-- |Set the fields of a struct index to the given value list.  The list corresponds to the field list and must match in size.+mStructSetFields :: MStructArray -> MIndex -> [MXArray a] -> MIO ()+mStructSetFields a i v = do+  o <- mIndexOffset a i+  withMXArray a (\a -> zipWithM_ (\v -> withMXArray v . mxSetFieldByNumber a (ii o)) v [0..])++instance MXArrayComponent MStruct where+  isMXArray a = liftM2 (||) (boolC =.< withMXArray a mxIsStruct) (boolC =.< withMXArray a mxIsObject)+  createMXArray s = createStruct s []+  mxArrayGetOffset a o = do+    f <- mStructFields a+    structGetOffsetFields a f o+  mxArraySetOffset = error "mxArraySet undefined for MStruct: use mStructSet"+  mxArrayGetOffsetList a o n = do+    f <- mStructFields a+    mapM (structGetOffsetFields a f) [o..o+n-1]+  createMXScalar (MStruct fv) = do+    a <- createStruct [1] f+    withMXArray a $ \a -> zipWithM_ (\i v -> withMXArray v (mxSetFieldByNumber a 0 i)) [0..] v+    return a+    where+      (f,v) = unzip fv++foreign import ccall unsafe mxGetClassName :: MXArrayPtr -> IO CString+-- |Determine if a struct array is a user defined object, and return its class name, if any.+mObjectGetClass :: MStructArray -> IO (Maybe String)+mObjectGetClass a = do+  b <- boolC =.< withMXArray a mxIsObject+  if b+    then Just =.< withMXArray a (mxGetClassName >=> peekCString)+    else return Nothing++foreign import ccall unsafe mxSetClassName :: MXArrayPtr -> CString -> IO CInt+-- |Set classname of an unvalidated object array.  It is illegal to call this function on a previously validated object array.+mObjectSetClass :: MStructArray -> String -> IO ()+mObjectSetClass a c = do+  r <- withMXArray a (withCString c . mxSetClassName)+  when (r /= 0) $ fail "mObjectSetClass"++castReal :: MXArray (Complex a) -> MXArray a+castReal = unsafeCastMXArray++foreign import ccall unsafe mxGetImagData :: MXArrayPtr -> IO (Ptr a)+withRealDataOff :: MXArrayData mx a => MXArray (Complex a) -> Int -> (Ptr mx -> IO b) -> IO b+withRealDataOff = withArrayDataOff . castReal+withImagDataOff :: MXArrayData mx a => MXArray (Complex a) -> Int -> (Ptr mx -> IO b) -> IO b+withImagDataOff a o f = withMXArray a (mxGetImagData >=> \p -> f (advancePtr p o))++foreign import ccall unsafe mxIsComplex :: MXArrayPtr -> IO CBool+mxArrayIsComplex :: MXArray a -> IO Bool+mxArrayIsComplex a = boolC =.< withMXArray a mxIsComplex++-- |Complex array access.+instance (RealFloat a, MNumeric a, MXArrayData mx a) => MXArrayComponent (MComplex a) where+  isMXArray a = liftM2 (&&) (isMXArray (castReal a)) (mxArrayIsComplex a)+  createMXArray s = withNDims s (uncurry $ createNumericArray (mxClassOf (undefined :: a)) True) >>= mkMXArray++  mxArrayGetOffset a o = do+    r <- withRealDataOff a o (mx2hs .=< peek)+    c <- withImagDataOff a o (mx2hs .=< peek)+    return $ r :+ c+  mxArraySetOffset a o (r :+ c) = do+    withRealDataOff a o (\p -> poke p (hs2mx r))+    withImagDataOff a o (\p -> poke p (hs2mx c))+  mxArrayGetOffsetList a o n = do+    r <- withRealDataOff a o (map mx2hs .=< peekArray n)+    c <- withImagDataOff a o (map mx2hs .=< peekArray n)+    return $ zipWith (:+) r c+  mxArraySetOffsetList a o v = do+    withRealDataOff a o (\p -> pokeArray p (map hs2mx r))+    withImagDataOff a o (\p -> pokeArray p (map hs2mx c))+    where (r,c) = unzip $ map (\(r:+c) -> (r,c)) v

@@ -0,0 +1,53 @@+{-|+  Direct conversion between Haskell data structures and 'IMXData'.++  In general, scalars convert to the obvious, and lists to row vectors.+-}+module Foreign.Matlab.Array.Able (+    Matlabable,+    toMatlab, fromMatlab,+    withMatlabArray, fromMatlabArray+  ) where++import Foreign.Matlab.Util+import Foreign.Matlab.Types+import Foreign.Matlab.Array.IMX++class Matlabable a where+  toMatlab :: a -> IMXData+  fromMatlab :: IMXData -> Maybe a++--instance (MScalar a, IMXArrayElem a) => Matlabable a where { toMatlab = scalarIMX ; fromMatlab = imxScalar }+instance Matlabable Bool   where { toMatlab = scalarIMX ; fromMatlab = imxScalar }+instance Matlabable Char   where { toMatlab = scalarIMX ; fromMatlab = imxScalar }+instance Matlabable Float  where { toMatlab = scalarIMX ; fromMatlab = imxScalar }+instance Matlabable Double where { toMatlab = scalarIMX ; fromMatlab = imxScalar }++instance Matlabable Int where +  toMatlab = scalarIMX . (ii :: Int -> MInt32)+  fromMatlab = fmap (ii :: MInt32 -> Int) . imxScalar++instance Matlabable String where+  toMatlab = listIMX [1,-1]+  fromMatlab = imxList ++instance Matlabable [Double] where+  toMatlab = listIMX [1,-1]+  fromMatlab = imxList ++instance Matlabable [Int] where+  toMatlab = listIMX [1,-1] . map (ii :: Int -> MInt32)+  fromMatlab = fmap (map (ii :: MInt32 -> Int)) . imxList++instance Matlabable () where+  toMatlab () = IMXNull+  fromMatlab IMXNull = Just ()+  fromMatlab _ = Nothing++-- |Generate a temporary 'MXArray'+withMatlabArray :: Matlabable a => a -> (MAnyArray -> IO a) -> IO a+withMatlabArray = withIMXData . toMatlab++-- |Convert directly from 'MXArray' (without freeing the original array)+fromMatlabArray :: Matlabable a => MAnyArray -> IO (Maybe a)+fromMatlabArray = fromMatlab .=< imxData

@@ -0,0 +1,33 @@+{-|+  'MXArray' 'ForeignPtr' wrapper.++  A 'MXArray' that is automatically freed.  These arrays must never be put inside other arrays or used as function results.+-}+module Foreign.Matlab.Array.Auto (+    MXAuto,+    mxAuto,+    withMXAuto,+    MAnyAuto+  ) where++import Foreign+import Foreign.Matlab.Util+import Foreign.Matlab.Internal+import Foreign.Matlab.Types++-- |A 'MXArray' that is automatically freed with 'Foreign.Matlab.Array.freeMXArray'+newtype MXAuto a = MXAuto (ForeignPtr MXArrayType)++foreign import ccall unsafe "&mxDestroyArray" mxDestroyArray_ptr :: FunPtr (MXArrayPtr -> IO ())++-- |Turn an 'MXArray' into an 'MXAuto'.  The original 'MXArray' should not be used after this operation.+mxAuto :: MXArray a -> MIO (MXAuto a)+mxAuto (MXArray a)+  | a == nullPtr = MXAuto =.< newForeignPtr_ a+  | otherwise = MXAuto =.< newForeignPtr mxDestroyArray_ptr a++-- |Use a 'MXAuto'+withMXAuto :: MXAuto a -> (MXArray a -> IO b) -> IO b+withMXAuto (MXAuto a) f = withForeignPtr a (f . MXArray)++type MAnyAuto = MXAuto MAny

@@ -0,0 +1,315 @@+{-|+  Safe immutable intermediate (functional) Matlab data structures.++  This provides an alternative representation of Matlab data structures which can be marshalled to and from 'MXArray'.+  An instance of 'Show' is provided which creates Matlab expressions.+-}+module Foreign.Matlab.Array.IMX (+    IMXData(..),+    IMXArrayElem,++    -- * Interface with "Foreign.Matlab.Array"+    imxData, iMXData,+    imxFun, iMXFun,+    withIMXData, takeIMXData,+    withIMXDataList,++    -- * Construction and access+    imxSize,+    imxConstr, imxArray,+    listIMX, scalarIMX,+    imxList, imxScalar,+    listIMXStruct,+    imxStructList+  ) where++import Control.Monad+import Data.Array.IArray+import Data.Complex+import Data.List+import Text.Show+import Foreign.Matlab.Util+import Foreign.Matlab.Internal+import Foreign.Matlab.Types+import Foreign.Matlab.Array++type IMXArray a = Array MIndex a+-- |The basic immutable (functional) representation of Matlab data structures, representing a generic 'MXArray'+data IMXData =+    IMXNull+  | IMXCell	(IMXArray IMXData)+  | IMXStruct   [String] (Array (MIndex,Int) IMXData) -- ^ field name list and array mapping (index,field index) to values+  | IMXLogical	(IMXArray MLogical)+  | IMXChar	(IMXArray MChar)+  | IMXDouble	(IMXArray MDouble)+  | IMXSingle	(IMXArray MSingle)+  | IMXInt8	(IMXArray MInt8)+  | IMXUint8	(IMXArray MUint8)+  | IMXInt16	(IMXArray MInt16)+  | IMXUint16	(IMXArray MUint16)+  | IMXInt32	(IMXArray MInt32)+  | IMXUint32	(IMXArray MUint32)+  | IMXInt64	(IMXArray MInt64)+  | IMXUint64	(IMXArray MUint64)+  | IMXComplexDouble	(IMXArray (MComplex MDouble))+  | IMXComplexSingle	(IMXArray (MComplex MSingle))+  | IMXObject   String IMXData -- ^ object class name and object data, currently always IMXStruct+  deriving (Eq)++type IMXFun = [IMXData] -> Int -> IO [IMXData]++fixMSize :: MSize -> [a] -> MSize+fixMSize s l = maybe s (\i -> replaceIndex s i (length l `div` negate (product s))) $ elemIndex (-1) s++-- |Create an sized array for 'IMXData' from a sequential list of elements.  'MSize' may contain at most one -1 value, which will be inferred from the length of the list.+listIMXArray :: MSize -> [e] -> IMXArray e+listIMXArray s l = listArray (mSizeRange (fixMSize s l)) l++-- |Create a scalar (array) for 'IMXData'+scalarIMXArray :: e -> IMXArray e+scalarIMXArray e = listIMXArray [] [e]++class IMXArrayElem a where+  -- |Generic 'IMXData' 'IMXArray' constructor+  imxConstr :: IMXArray a -> IMXData+  -- |Generic 'IMXData' 'IMXArray' accessor+  imxArray :: IMXData -> Maybe (IMXArray a)+instance IMXArrayElem IMXData  where { imxConstr = IMXCell    ; imxArray (IMXCell    a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MLogical where { imxConstr = IMXLogical ; imxArray (IMXLogical a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MChar    where { imxConstr = IMXChar    ; imxArray (IMXChar    a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MDouble  where { imxConstr = IMXDouble  ; imxArray (IMXDouble  a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MSingle  where { imxConstr = IMXSingle  ; imxArray (IMXSingle  a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MInt8    where { imxConstr = IMXInt8    ; imxArray (IMXInt8    a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MUint8   where { imxConstr = IMXUint8   ; imxArray (IMXUint8   a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MInt16   where { imxConstr = IMXInt16   ; imxArray (IMXInt16   a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MUint16  where { imxConstr = IMXUint16  ; imxArray (IMXUint16  a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MInt32   where { imxConstr = IMXInt32   ; imxArray (IMXInt32   a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MUint32  where { imxConstr = IMXUint32  ; imxArray (IMXUint32  a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MInt64   where { imxConstr = IMXInt64   ; imxArray (IMXInt64   a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem MUint64  where { imxConstr = IMXUint64  ; imxArray (IMXUint64  a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem (MComplex MDouble) where { imxConstr = IMXComplexDouble ; imxArray (IMXComplexDouble a) = Just a ; imxArray _ = Nothing }+instance IMXArrayElem (MComplex MSingle) where { imxConstr = IMXComplexSingle ; imxArray (IMXComplexSingle a) = Just a ; imxArray _ = Nothing }++-- |Generic 'IMXData' list constructor.  Specified 'MSize' may contain at most one -1 value, which will be inferred from the length of the list.+listIMX :: IMXArrayElem a => MSize -> [a] -> IMXData+listIMX s = imxConstr . listIMXArray s+-- |Generic 'IMXData' scalar constructor+scalarIMX :: IMXArrayElem a => a -> IMXData+scalarIMX = imxConstr . scalarIMXArray+--emptyIMX :: IMXArrayElem a => a -> IMXData+--emptyIMX a = listIMX [0] ([] `asTypeOf` [a])++-- |Generic 'IMXData' array size accessor+imxSize :: IMXData -> MSize+imxSize IMXNull = [0]+imxSize (IMXCell    a) = mRangeSize (bounds a)+imxSize (IMXLogical a) = mRangeSize (bounds a)+imxSize (IMXChar    a) = mRangeSize (bounds a)+imxSize (IMXDouble  a) = mRangeSize (bounds a)+imxSize (IMXSingle  a) = mRangeSize (bounds a)+imxSize (IMXInt8    a) = mRangeSize (bounds a)+imxSize (IMXUint8   a) = mRangeSize (bounds a)+imxSize (IMXInt16   a) = mRangeSize (bounds a)+imxSize (IMXUint16  a) = mRangeSize (bounds a)+imxSize (IMXInt32   a) = mRangeSize (bounds a)+imxSize (IMXUint32  a) = mRangeSize (bounds a)+imxSize (IMXInt64   a) = mRangeSize (bounds a)+imxSize (IMXUint64  a) = mRangeSize (bounds a)+imxSize (IMXComplexDouble a) = mRangeSize (bounds a)+imxSize (IMXComplexSingle a) = mRangeSize (bounds a)+imxSize (IMXStruct _ a) = mRangeSize (r0,r1) where ((r0,_),(r1,_)) = bounds a+imxSize (IMXObject _ d) = imxSize d++-- |Generic 'IMXData' list accessor+imxList :: IMXArrayElem a => IMXData -> Maybe [a]+imxList = fmap elems . imxArray+-- |Generic 'IMXData' scalar accessor+imxScalar :: IMXArrayElem a => IMXData -> Maybe a+imxScalar a = case imxList a of +  Just [x] -> Just x+  _ -> Nothing++-- |Create a sized struct array from a sequential list of consecutive field values (@[i0f0,i0f1,...,i0fM,i1f0,i1f1,....,iNfM]@).+listIMXStruct :: [String] -> MSize -> [IMXData] -> IMXData+listIMXStruct f s l = IMXStruct f $ listArray r l where+  n = length f+  r = ((r0,0),(r1,pred n))+  (r0,r1) = mSizeRange $ tail $ fixMSize (n:s) l++-- |Access a struct as list of fields and list of consecutive field values+imxStructList :: IMXData -> Maybe ([String], [IMXData])+imxStructList (IMXStruct f v) = Just (f, elems v)+imxStructList _ = Nothing++-- |Create an immutable representation from an 'MXArray'+imxData :: MXArray a -> IO IMXData+imxData a = do+  t <- mxArrayClass a+  c <- if t /= MXClassNull then mxArrayIsComplex a else return undefined+  imxc t c where+  +  imxc :: MXClass -> Bool -> IO IMXData+  imxc MXClassNull _		= return IMXNull+  imxc MXClassCell False	= IMXCell	=.< imxa (imxData . mCell)+  imxc MXClassStruct False	= do+    s <- mxArraySize a'+    fv <- mxArrayGetAll a'+    f <- if null fv then mStructFields a' else return (map fst (mStruct (head fv)))+    listIMXStruct f s =.< mapM imxData (concatMap (map snd . mStruct) fv)+  imxc MXClassLogical False	= IMXLogical	=.< imxa return+  imxc MXClassChar False	= IMXChar	=.< imxa return+  imxc MXClassDouble False	= IMXDouble	=.< imxa return+  imxc MXClassSingle False	= IMXSingle	=.< imxa return+  imxc MXClassInt8 False	= IMXInt8	=.< imxa return+  imxc MXClassUint8 False	= IMXUint8	=.< imxa return+  imxc MXClassInt16 False	= IMXInt16	=.< imxa return+  imxc MXClassUint16 False	= IMXUint16	=.< imxa return+  imxc MXClassInt32 False	= IMXInt32	=.< imxa return+  imxc MXClassUint32 False	= IMXUint32	=.< imxa return+  imxc MXClassInt64 False	= IMXInt64	=.< imxa return+  imxc MXClassUint64 False	= IMXUint64	=.< imxa return+  imxc MXClassDouble True	= IMXComplexDouble	=.< imxa return+  imxc MXClassSingle True	= IMXComplexSingle	=.< imxa return+  imxc MXClassObject False	= do+    Just c <- mObjectGetClass a'+    IMXObject c =.< imxc MXClassStruct False+  imxc t c = fail ("imxData: unhandled mxArray type " ++ show t ++ if c then "(complex)" else "")++  imxa :: MXArrayComponent a => (a -> IO b) -> IO (IMXArray b)+  imxa f = do+    s <- mxArraySize a'+    listIMXArray s =.< mapM f =<< mxArrayGetAll a'++  a' = unsafeCastMXArray a++-- |Create a new 'MXArray' from a functional representation.+iMXData :: IMXData -> IO MAnyArray+iMXData = imxd where+  imxd :: IMXData -> IO MAnyArray+  imxd IMXNull = return $ anyMXArray mNullArray+  imxd (IMXCell a) = imxa a (MCell .=< iMXData)+  imxd (IMXStruct f a) = do+    let ((r0,_),(r1,_)) = bounds a+    m <- createStruct (mRangeSize (r0,r1)) f+    zipWithM (\i -> mStructSetFields m (mOffset i) <=< mapM iMXData) [0..] (segment (length f) (elems a))+    return $ anyMXArray m+  imxd (IMXLogical a)	= imxa a return+  imxd (IMXChar a)	= imxa a return+  imxd (IMXDouble a)	= imxa a return+  imxd (IMXSingle a)	= imxa a return+  imxd (IMXInt8 a)	= imxa a return+  imxd (IMXUint8 a)	= imxa a return+  imxd (IMXInt16 a)	= imxa a return+  imxd (IMXUint16 a)	= imxa a return+  imxd (IMXInt32 a)	= imxa a return+  imxd (IMXUint32 a)	= imxa a return+  imxd (IMXInt64 a)	= imxa a return+  imxd (IMXUint64 a)  	= imxa a return+  imxd (IMXComplexDouble a) = imxa a return+  imxd (IMXComplexSingle a) = imxa a return+  imxd (IMXObject c a) = do+    m <- imxd a+    mObjectSetClass (unsafeCastMXArray m) c+    return m++  imxa :: MXArrayComponent b => IMXArray a -> (a -> IO b) -> IO MAnyArray+  imxa a f = do+    m <- createMXArray (mRangeSize (bounds a))+    mxArraySetAll m =<< mapM f (elems a)+    return $ anyMXArray m++withIMXData :: IMXData -> (MAnyArray -> IO a) -> IO a+withIMXData d f = do+  a <- iMXData d+  r <- f a+  freeMXArray a+  return r++withIMXDataList :: [IMXData] -> ([MAnyArray] -> IO a) -> IO a+withIMXDataList = mapWith withIMXData++takeIMXData :: MXArray a -> IO IMXData+takeIMXData a = do+  d <- imxData a+  freeMXArray a+  return d++imxFun :: MFun -> IMXFun+imxFun fun a no =+  mapWith withIMXData a $ \m ->+  fun m no >>= mapM takeIMXData++iMXFun :: IMXFun -> MFun+iMXFun fun a no = do+  ia <- mapM imxData a+  fun ia no >>= mapM iMXData+++showsApp :: String -> ShowS -> ShowS+showsApp f a s = f ++ '(' : a (')' : s)++{-+showsReshape :: (MIndex,MIndex) -> ShowS -> ShowS+showsReshape (MSubs [],MSubs []) a s = a s+showsReshape (MSubs [],MSubs []) a s = a s+showsReshape r a s = "reshape(" ++ a (',' : shows (realMSize $ mRangeSize r) (')' : s))++showsIMXArrayDelimWith :: (Char,Char,Char) -> (a -> ShowS) -> IMXArray a -> ShowS+showsIMXArrayDelimWith d f a = showsReshape (bounds a) $ showsMListWith d f (elems a)+showsIMXArrayWith :: (a -> ShowS) -> IMXArray a -> ShowS+showsIMXArrayWith = showsIMXArrayDelimWith ('[',',',']')+showsIMXArray :: Show a => IMXArray a -> ShowS+showsIMXArray = showsIMXArrayWith shows+-}++showsMList :: (Char,Char,Char) -> (a -> ShowS) -> [a] -> ShowS+showsMList (l,_,r) _ [] s = l : r : s+showsMList (l,d,r) f (x:xs) s = l : f x (shml xs) where+  shml [] = r : s+  shml (x:xs) = d : f x (shml xs)++showsReshape :: MSize -> (Char -> ShowS) -> ShowS+showsReshape [] f s = f ' ' s+showsReshape [_] f s = f ';' s+showsReshape [1,_] f s = f ',' s+showsReshape z f s = "reshape(" ++ f ' ' (',' : showsMList ('[',' ',']') shows (realMSize z) (')' : s))++showsIMXGenArray :: (Char,Char) -> (a -> ShowS) -> IMXArray a -> ShowS+showsIMXGenArray (l,r) f a = showsReshape (mRangeSize $ bounds a) $ \d -> showsMList (l,d,r) f (elems a)+showsIMXArrayWith :: (a -> ShowS) -> IMXArray a -> ShowS+showsIMXArrayWith = showsIMXGenArray ('[',']')+showsIMXArray :: Show a => IMXArray a -> ShowS+showsIMXArray = showsIMXArrayWith shows++showsComplex :: (Show a, RealFloat a) => Complex a -> ShowS+showsComplex (x:+y) s = "complex(" ++ shows x (',' : shows y (')' : s))++showsMString :: String -> ShowS+showsMString s = showChar '\'' . showString s . showChar '\''++showsIMX :: IMXData -> ShowS+showsIMX IMXNull = showString "[]"+showsIMX (IMXCell a) = showsIMXGenArray ('{','}') shows a+showsIMX (IMXStruct f a) = showsReshape (mRangeSize (r0,r1)) $ \d ->+  showString "struct" . showsMList ('(',',',')') (shf d) (zip f v) where+  shf d (f,v) s = showsMString f $ ',' : showsMList ('{',d,'}') showsIMX v s+  v = transpose $ segment (length f) $ elems a+  ((r0,_),(r1,_)) = bounds a+showsIMX (IMXLogical a) = showsApp "logical"  $ showsIMXArray a+showsIMX (IMXChar a)	= showsApp "char"     $ showsIMXArray a+showsIMX (IMXDouble a)	=                       showsIMXArray a+showsIMX (IMXSingle a)	= showsApp "single"   $ showsIMXArray a+showsIMX (IMXInt8 a)	= showsApp "int8"     $ showsIMXArray a+showsIMX (IMXUint8 a)	= showsApp "uint8"    $ showsIMXArray a+showsIMX (IMXInt16 a)	= showsApp "int16"    $ showsIMXArray a+showsIMX (IMXUint16 a)	= showsApp "uint16"   $ showsIMXArray a+showsIMX (IMXInt32 a)	= showsApp "int32"    $ showsIMXArray a+showsIMX (IMXUint32 a)	= showsApp "uint32"   $ showsIMXArray a+showsIMX (IMXInt64 a)	= showsApp "int64"    $ showsIMXArray a+showsIMX (IMXUint64 a)	= showsApp "uint64"   $ showsIMXArray a+showsIMX (IMXComplexDouble a)	= showsIMXArrayWith showsComplex a+showsIMX (IMXComplexSingle a)	= showsApp "single" $ showsIMXArrayWith showsComplex a+showsIMX (IMXObject c a) = showsApp "class" $ showsIMX a . showChar ',' . showsMString c++instance Show IMXData where+  showsPrec _ = showsIMX

@@ -0,0 +1,38 @@+{-|+  Safe MArray interface to "Foreign.Matlab.Array".++  An instance of 'Data.Array.MArray.MArray' for 'MXArray'.  Although array access can be done through this instance, arrays themselves must be created using 'mxMArray' along with one of the "Foreign.Matlab.Array" create functions.+-}+module Foreign.Matlab.Array.MArray (+    MMXArray, mxMArray, unMmxArray+  ) where++import qualified Data.Ix as Ix+import qualified Data.Array.Base as DA+import qualified Unsafe.Coerce+import Foreign.Matlab.Util+import Foreign.Matlab.Types+import Foreign.Matlab.Array++-- |A wrapper for 'MXArray' to allow for a 'Data.Array.MArray.MArray' instance.  All instances of this type will have 'MIndex' as @i@+newtype MMXArray i e = MMXArray { mmxArray :: MXArray e }++-- |Get an 'Data.Array.MArray.MArray' instance for an 'MXArray'.  The resulting object is just a different interface to the same underlying array.+mxMArray :: MXArrayComponent a => MXArray a -> MMXArray MIndex a+mxMArray = MMXArray+-- |Get a 'MXArray' back from its 'Data.Array.MArray.MArray' instance+unMmxArray :: MXArrayComponent a => MMXArray MIndex a -> MXArray a+unMmxArray = mmxArray++mix :: Ix.Ix a => MIndex -> a+mix x = Unsafe.Coerce.unsafeCoerce x+mir :: Ix.Ix a => (MIndex,MIndex) -> (a,a)+mir (x,y) = (mix x,mix y)++instance MXArrayComponent e => DA.MArray MMXArray e IO where+  getBounds = mir . mSizeRange .=< mxArraySize . mmxArray+  getNumElements = mxArrayLength . mmxArray+  newArray_ _ = fail "MMXArray.newArray_: use MXArrayI . createMXArray"+  unsafeRead = mxArrayGetOffset . mmxArray+  unsafeWrite = mxArraySetOffset . mmxArray+

@@ -0,0 +1,1 @@+-- FIXME: This file needs to be regenerated from Config.hs.in by configure, but is required to exist for sdist.

@@ -0,0 +1,11 @@+module Foreign.Matlab.Config (matlabPath, matlabBin, matlabArch, dllExtension) where++import Distribution.Simple.BuildPaths (dllExtension)++matlabPath :: FilePath+matlabBin :: FilePath+matlabArch :: String++matlabPath = "@MATLAB_DIR@"+matlabBin = "@MATLAB_BIN@"+matlabArch = "@MATLAB_ARCH@"

@@ -0,0 +1,87 @@+{-|+  Interface to a Matlab engine.+  This works by spawning a separate matlab process and interchanging data in MAT format.++  Note that you cannot use "Foreign.Matlab.Engine" and "Foreign.Matlab.Runtime" in the same program.+  This seems to be a Matlab limitation.+-}+module Foreign.Matlab.Engine (+    Engine,+    newEngine,+    engineEval,+    engineGetVar,+    engineSetVar,+    EngineEvalArg(..),+    engineEvalFun+  ) where++import Control.Monad+import Foreign+import Foreign.C.String+import Foreign.C.Types+import Data.List+import Foreign.Matlab.Util+import Foreign.Matlab.Internal+import Foreign.Matlab.Types+import Foreign.Matlab.Config++#include <engine.h>++data EngineType+type EnginePtr = Ptr EngineType++-- |A Matlab engine instance+newtype Engine = Engine (ForeignPtr EngineType)++foreign import ccall unsafe engOpen :: CString -> IO EnginePtr+foreign import ccall unsafe "&" engClose :: FunPtr (EnginePtr -> IO ()) -- CInt++-- |Start Matlab server process.  It will automatically be closed down when no longer in use.+newEngine :: Maybe FilePath -> IO Engine+newEngine Nothing = newEngine (Just matlabBin)+newEngine (Just bin) = do+  eng <- withCString bin engOpen+  if eng == nullPtr+    then fail "engOpen"+    else Engine =.< newForeignPtr engClose eng++withEngine :: Engine -> (EnginePtr -> IO a) -> IO a+withEngine (Engine eng) = withForeignPtr eng++foreign import ccall unsafe engEvalString :: EnginePtr -> CString -> IO CInt+-- |Execute matlab statement+engineEval :: Engine -> String -> IO ()+engineEval eng s = do +  r <- withEngine eng (withCString s . engEvalString)+  when (r /= 0) $ fail "engineEval"++foreign import ccall unsafe engGetVariable :: EnginePtr -> CString -> IO MXArrayPtr+-- |Get a variable with the specified name from MATLAB's workspace+engineGetVar :: Engine -> String -> IO (MXArray a)+engineGetVar eng v = withEngine eng (withCString v . engGetVariable) >>= mkMXArray++foreign import ccall unsafe engPutVariable :: EnginePtr -> CString -> MXArrayPtr -> IO CInt+-- |Put a variable into MATLAB's workspace with the specified name+engineSetVar :: Engine -> String -> MXArray a -> IO ()+engineSetVar eng v x = do+  r <- withEngine eng (\eng -> withCString v (withMXArray x . engPutVariable eng))+  when (r /= 0) $ fail "engineSetVar"++data EngineEvalArg a = EvalArray (MXArray a) | EvalVar String++-- |Evaluate a function with the given arguments and number of results.+-- This automates 'engineSetVar' on arguments (using \"hseval_inN\"), 'engineEval', and 'engineGetVar' on results (using \"hseval_outN\").+engineEvalFun :: Engine -> String -> [EngineEvalArg a] -> Int -> IO [MAnyArray]+engineEvalFun eng fun arg no = do+  arg <- zipWithM makearg arg [1 :: Int ..]+  let out = map makeout [1..no]+  let outs = if out == [] then "" else "[" ++ unwords out ++ "] = "+  engineEval eng (outs ++ fun ++ "(" ++ intercalate "," arg ++ ")")+  mapM (engineGetVar eng) out+  where+    makearg (EvalArray x) i = do+      let v = "hseval_in" ++ show i+      engineSetVar eng v x+      return v+    makearg (EvalVar v) _ = return v+    makeout i = "hseval_out" ++ show i

@@ -0,0 +1,215 @@+module Foreign.Matlab.Internal (+    CBool, boolC, cBool,+    MIO,+    MType(..),+    MXClassID, MXClass(..),+    MXChar, MChar,+    MXLogical, MLogical,+    MXDouble, MDouble,+    MXSingle, MSingle,+    MXInt8, MInt8,+    MXInt16, MInt16,+    MXInt32, MInt32,+    MXInt64, MInt64,+    MXUint8, MUint8,+    MXUint16, MUint16,+    MXUint32, MUint32,+    MXUint64, MUint64,+    MXArrayType,+    MXArrayPtr, MXArray(..),+    mkMXArray, withMXArray,+    unsafeCastMXArray,+    MAny, MAnyArray,+    MNull, mNullArray, isMNull,+    MCell(..),+    MStruct(..),+    MFun,+    MWSize, MWIndex, MWSignedIndex+  ) where++import Foreign+import Foreign.C.Types+import qualified Data.Char+import Data.Typeable+import Foreign.Matlab.Util++#include <matrix.h>++type MIO a = IO a++type CBool = #type bool++boolC :: CBool -> Bool+boolC = (0 /=)++cBool :: Bool -> CBool+cBool = ii . fromEnum++type MXClassID = #type mxClassID+data MXClass = +    MXClassNull+  | MXClassCell +  | MXClassStruct+  | MXClassLogical+  | MXClassChar+  | MXClassDouble+  | MXClassSingle+  | MXClassInt8+  | MXClassUint8+  | MXClassInt16+  | MXClassUint16+  | MXClassInt32+  | MXClassUint32+  | MXClassInt64+  | MXClassUint64+  | MXClassFun+  | MXClassObject+  deriving (Eq, Show)++-- |A type equivalence between a Matlab and Haskell type+class MType mx a | a -> mx where+  hs2mx :: a -> mx+  mx2hs :: mx -> a+  mxClassOf :: a -> MXClass++instance MType MXClassID MXClass where+  mx2hs (#const mxVOID_CLASS) = MXClassNull+  mx2hs (#const mxCELL_CLASS)    = MXClassCell+  mx2hs (#const mxSTRUCT_CLASS)  = MXClassStruct+  mx2hs (#const mxLOGICAL_CLASS) = MXClassLogical+  mx2hs (#const mxCHAR_CLASS)    = MXClassChar+  mx2hs (#const mxDOUBLE_CLASS)  = MXClassDouble+  mx2hs (#const mxSINGLE_CLASS)  = MXClassSingle+  mx2hs (#const mxINT8_CLASS)    = MXClassInt8+  mx2hs (#const mxUINT8_CLASS)   = MXClassUint8+  mx2hs (#const mxINT16_CLASS)   = MXClassInt16+  mx2hs (#const mxUINT16_CLASS)  = MXClassUint16+  mx2hs (#const mxINT32_CLASS)   = MXClassInt32+  mx2hs (#const mxUINT32_CLASS)  = MXClassUint32+  mx2hs (#const mxINT64_CLASS)   = MXClassInt64+  mx2hs (#const mxUINT64_CLASS)  = MXClassUint64+  mx2hs (#const mxFUNCTION_CLASS)= MXClassFun+  mx2hs (#const mxOBJECT_CLASS)	 = MXClassObject+  mx2hs c = error ("MXClass: unknown mxClassID " ++ show c)+  hs2mx MXClassNull     = #const mxVOID_CLASS+  hs2mx MXClassCell     = #const mxCELL_CLASS+  hs2mx MXClassStruct   = #const mxSTRUCT_CLASS+  hs2mx MXClassLogical  = #const mxLOGICAL_CLASS+  hs2mx MXClassChar     = #const mxCHAR_CLASS+  hs2mx MXClassDouble   = #const mxDOUBLE_CLASS+  hs2mx MXClassSingle   = #const mxSINGLE_CLASS+  hs2mx MXClassInt8     = #const mxINT8_CLASS+  hs2mx MXClassUint8    = #const mxUINT8_CLASS+  hs2mx MXClassInt16    = #const mxINT16_CLASS+  hs2mx MXClassUint16   = #const mxUINT16_CLASS+  hs2mx MXClassInt32    = #const mxINT32_CLASS+  hs2mx MXClassUint32   = #const mxUINT32_CLASS+  hs2mx MXClassInt64    = #const mxINT64_CLASS+  hs2mx MXClassUint64   = #const mxUINT64_CLASS+  hs2mx MXClassFun      = #const mxFUNCTION_CLASS+  hs2mx MXClassObject   = #const mxOBJECT_CLASS	 +  mxClassOf _ = error "mxClassOf: no class for MXClassID"++type MXChar = #type mxChar+type MChar = Char+instance MType MXChar MChar where+  hs2mx = ii . Data.Char.ord+  mx2hs = Data.Char.chr . ii+  mxClassOf _ = MXClassChar++type MXLogical = #type mxLogical+type MLogical = Bool+instance MType MXLogical MLogical where+  hs2mx = cBool+  mx2hs = boolC+  mxClassOf _ = MXClassLogical++type MXDouble = Double+type MDouble = Double+instance MType MXDouble MDouble where+  hs2mx = id+  mx2hs = id+  mxClassOf _ = MXClassDouble+type MXSingle = Float+type MSingle = Float+instance MType MXSingle MSingle where+  hs2mx = id+  mx2hs = id+  mxClassOf _ = MXClassSingle++#let inttype u, n = "\+type MX%2$s%1$u = %3$s%1$u\n\+type M%2$s%1$u = %3$s%1$u\n\+instance MType MX%2$s%1$u M%2$s%1$u where { hs2mx = id ; mx2hs = id ; mxClassOf _ = MXClass%2$s%1$u }\+", n, u ? "Uint" : "Int", u ? "Word" : "Int"+--"++#inttype 0, 8+#inttype 0, 16+#inttype 0, 32+#inttype 0, 64+#inttype 1, 8+#inttype 1, 16+#inttype 1, 32+#inttype 1, 64++data MXArrayType+type MXArrayPtr = Ptr MXArrayType++-- |The general Matlab Array type, used for most all Matlab data+newtype MXArray a = MXArray { mxArray :: MXArrayPtr }++mkMXArray :: MXArrayPtr -> IO (MXArray a)+mkMXArray = return . MXArray++withMXArray :: With (MXArray x) MXArrayPtr a+withMXArray (MXArray a) f = f a++unsafeCastMXArray :: MXArray a -> MXArray b+unsafeCastMXArray = MXArray . castPtr . mxArray++-- |Determine whether the given array is NULL+isMNull :: MXArray a -> Bool+isMNull (MXArray a) = nullPtr == a++-- |Tag for a generic array+data MAny+-- |A generic, untyped (void) array, which must be cast (using 'Foreign.Matlab.Array.castMXArray')+type MAnyArray = MXArray MAny++-- |Tag for a NULL array+data MNull deriving (Typeable)+instance MType MNull MNull where mxClassOf _ = MXClassNull++mNullArray :: MXArray MNull+mNullArray = MXArray nullPtr++-- |A wrapper for a member of a cell array, which itself simply any other array+newtype MCell = MCell { mCell :: MAnyArray } deriving (Typeable)+instance MType MCell MCell where mxClassOf _ = MXClassCell++-- |A single struct in an array, represented by an (ordered) list of key-value pairs+newtype MStruct = MStruct { mStruct :: [(String,MAnyArray)] } deriving (Typeable)+instance MType MStruct MStruct where mxClassOf _ = MXClassStruct++type MXFun = CInt -> Ptr MXArrayPtr -> CInt -> Ptr MXArrayPtr -> IO ()+-- |A Matlab function+type MFun = +  [MAnyArray] -- ^ RHS input arguments+  -> Int -- ^ LHS output argument count+  -> IO [MAnyArray] -- ^ LHS output arguments+instance MType MXFun MFun where+  hs2mx fun outn outp argn argp = do+    arg <- map MXArray =.< peekArray (ii argn) argp+    out <- fun arg (ii outn)+    pokeArray outp $ map mxArray out+  mx2hs fun arg no =+    withArrayLen (map mxArray arg) $ \argn argp ->+    allocaArray no $ \outp -> do+    fun (ii no) outp (ii argn) argp+    map MXArray =.< peekArray no outp+  mxClassOf _ = MXClassFun++type MWSize = #type mwSize+type MWIndex = #type mwIndex+type MWSignedIndex = #type mwSignedIndex

@@ -0,0 +1,118 @@+{-|+  Read and write MAT-format Matlab data files.+-}+module Foreign.Matlab.MAT (+    MATFile,+    MATMode(..),+    matOpen,+    matSet,+    matGet,+    matRemove,+    matList,+    -- ** Convenience whole-file operations+    matLoad,+    matSave+  ) where++import Control.Monad+import Foreign+import Foreign.C.Types+import Foreign.C.String+import Foreign.C.Error+import Foreign.Matlab.Util+import Foreign.Matlab.Internal+import Foreign.Matlab.Types++#include <mat.h>++data MATFileType+type MATFilePtr = Ptr MATFileType+-- |The opaque type of MAT file handles+newtype MATFile = MATFile MATFilePtr++withMATFile :: With MATFile MATFilePtr (IO a)+withMATFile (MATFile mat) f = f mat++foreign import ccall unsafe "matOpen" matOpen_c :: CString -> CString -> IO MATFilePtr+foreign import ccall unsafe "matClose" matClose_c :: MATFilePtr -> IO CInt++data MATMode = MATRead | MATWrite | MATUpdate++-- |Open a MAT-file using mode.+matOpen :: FilePath -> MATMode -> IO MATFile+matOpen f m = do +  throwErrnoIfNull ("matOpen: " ++ f)+    (withCString f (withCString (ms m) . matOpen_c))+    >.= MATFile+  where+    ms MATRead = "r"+    ms MATWrite = "w"+    ms MATUpdate = "u"++-- |Close a MAT-file opened with matOpen.+matClose :: MATFile -> IO ()+matClose m = throwErrnoIfMinus1_ "matClose" $ withMATFile m matClose_c++foreign import ccall unsafe matPutVariable :: MATFilePtr -> CString -> MXArrayPtr -> IO CInt+foreign import ccall unsafe matPutVariableAsGlobal :: MATFilePtr -> CString -> MXArrayPtr -> IO CInt+-- |Write array value with the specified name to the MAT-file, deleting any previously existing variable with that name in the MAT-file.+matSet :: MATFile +  -> Bool -- ^ Global. If true, the variable will be written such that when the MATLAB LOAD command loads the variable, it will automatically place it in the global workspace.+  -> String -> MXArray a -> IO ()+matSet m g n v = do+  r <- withMATFile m (\m -> withCString n (withMXArray v . (if g then matPutVariableAsGlobal else matPutVariable) m))+  when (r /= 0) $ fail "matPut"++foreign import ccall unsafe matGetVariable :: MATFilePtr -> CString -> IO MXArrayPtr+-- |Read the array value for the specified variable name from a MAT-file.+matGet :: MATFile -> String -> IO (Maybe MAnyArray)+matGet m n = do+  a <- withMATFile m (withCString n . matGetVariable) +  if a == nullPtr+    then return Nothing+    else Just =.< mkMXArray a++foreign import ccall unsafe matDeleteVariable :: MATFilePtr -> CString -> IO CInt+-- |Remove a variable with with the specified name from the MAT-file.+matRemove :: MATFile -> String -> IO ()+matRemove m n = do+  r <- withMATFile m (withCString n . matDeleteVariable)+  when (r /= 0) $ fail "matRemove"++foreign import ccall unsafe mxFree :: Ptr a -> IO ()++foreign import ccall unsafe matGetDir :: MATFilePtr -> Ptr CInt -> IO (Ptr CString)+-- |Get a list of the names of the arrays in a MAT-file.+matList :: MATFile -> IO [String]+matList m =+  withMATFile m $ \m -> alloca $ \n -> do+  sp <- matGetDir m n+  n <- peek n+  when (n < 0) $ fail "matList"+  s <- mapM peekCString =<< peekArray (ii n) sp+  mxFree sp+  return s++foreign import ccall unsafe matGetNextVariable :: MATFilePtr -> Ptr CString -> IO MXArrayPtr+-- |Load all the variables from a MAT file+matLoad :: FilePath -> IO [(String,MAnyArray)]+matLoad file = do+  mat <- matOpen file MATRead+  vars <- withMATFile mat load+  matClose mat+  return vars+  where+    load m =+      alloca $ \n -> do+      a <- matGetNextVariable m n+      if a == nullPtr then return [] else do+      a <- mkMXArray a+      n <- peek n >>= peekCString+      ((n,a) :) =.< load m++-- |Write all the variables to a new MAT file+matSave :: FilePath -> [(String,MXArray a)] -> IO ()+matSave file vars = do+  mat <- matOpen file MATWrite+  mapM_ (uncurry $ matSet mat False) vars+  matClose mat

@@ -0,0 +1,139 @@+{-|+  Interface to Matlab runtime libraries.+  This uses a Matlab shared library which has been built with \"mcc -l\", and only functions in this library may be called.+  Multiple libraries may be loaded simultaneously.++  Note that you cannot use "Foreign.Matlab.Runtime" and "Foreign.Matlab.Engine" in the same program.+  This seems to be a Matlab limitation.+-}+module Foreign.Matlab.Runtime (+    MLibrary,+    openMLibrary,+    closeMLibrary,+    mLibraryFun,+    mLibraryCall,++    mlGenericFeval+  ) where++import Control.Monad+import Foreign+import Foreign.C.String+import Foreign.C.Types+import System.Posix.DynamicLinker+import Data.List+import qualified Data.Char+import Control.Concurrent.MVar+import System.FilePath+import Foreign.Matlab.Config+import Foreign.Matlab.Util+import Foreign.Matlab.Internal+import Foreign.Matlab.Types++#include "hsc_sym.h"+#include "libhsmatlab.h"++initialized :: MVar Integer+initialized = unsafePerformIO (newMVar 0)++type InitApp = Ptr CString -> CInt -> IO CBool+type TermApp = IO CBool++initializeApp :: InitApp -> [String] -> IO ()+initializeApp init opt = modifyMVar_ initialized maybeinit where+  maybeinit 0 = +    mapWithArrayLen withCString opt $ \(optp,optn) -> do+    r <- init optp (ii optn)+    if boolC r+      then return 1+      else fail "mclInitializeApplication"+  maybeinit n = return $ succ n++terminateApp :: TermApp -> IO ()+terminateApp term = modifyMVar_ initialized maybeterm where+  maybeterm 1 = do+    r <- term+    if boolC r+      then return 0+      else fail "mclTerminateApplication"+  maybeterm n = return $ pred n++{-+foreign import ccall unsafe mclInitializeApplication :: InitApp+foreign import ccall unsafe mclTerminateApplication :: TermApp+initialize = initializeApp mclInitializeApplication+terminate = terminateApp mclTerminateApplication+-}++foreign import ccall "dynamic" mkInitApp :: FunPtr a -> InitApp+foreign import ccall "dynamic" mkTermApp :: FunPtr a -> TermApp++type InitFun = IO CBool+type FiniFun = IO ()+type MLXFun = CInt -> Ptr MXArrayPtr -> CInt -> Ptr MXArrayPtr -> IO CBool++foreign import ccall "dynamic" mkInitFun :: FunPtr a -> InitFun+foreign import ccall "dynamic" mkFiniFun :: FunPtr a -> FiniFun+foreign import ccall "dynamic" mkMLXFun :: FunPtr a -> MLXFun++-- |A Matlab library handle+data MLibrary = MLibrary { mlName :: String, mlDL :: DL }++-- |Open and initialize a matlab shared library.+openMLibrary :: +  String  -- ^ The name of the library, which may be a full path to the file, or simply the library name+  -> [String] -- ^ Arguments with which to initialize the application instance (e.g., \"-nojvm\")+  -> IO MLibrary+openMLibrary mlname opt = do+  let (path, base) = splitFileName mlname+      name = (if isPrefixOf "lib" base then drop 3 else id) (dropExtensions base)+      file = (if isPrefixOf "lib" base then id else ("lib" ++)) ((if isSuffixOf dllExtension base || isInfixOf (dllExtension++[extSeparator]) base then id else (<.> dllExtension)) base)+  dl <- dlopen (path </> file) [RTLD_NOW]+  let ml = MLibrary name dl+  inia <- mkInitApp =.< dlsym dl #SYM mclInitializeApplication+  initializeApp inia opt+  --initialize opt+  inif <- mkInitFun =.< dlsym dl ("lib" ++ name ++ "Initialize")+  r <- inif+  if boolC r+    then return ml+    else fail ("lib" ++ name ++ "Initialize")++-- |Terminate and close a matlab library.+closeMLibrary :: MLibrary -> IO ()+closeMLibrary (MLibrary name dl) = do+  fini <- mkFiniFun =.< dlsym dl ("lib" ++ name ++ "Terminate")+  fini+  fina <- mkTermApp =.< dlsym dl #SYM mclTerminateApplication+  terminateApp fina+  --terminate+  dlclose dl++makeMFun :: MLXFun -> MFun+makeMFun fun arg no =+  mapWithArrayLen withMXArray arg $ \(argp,argn) ->+  allocaArray no $ \outp -> do+  r <- fun (ii no) outp (ii argn) argp+  if boolC r+    then peekArray no outp >>= mapM mkMXArray+    else fail "MFun"++-- |Return a Haskell function representing the Matlab function with the given name in the given library+mLibraryFun :: MLibrary -> String -> IO MFun+mLibraryFun (MLibrary _ dl) fun =+  (makeMFun . mkMLXFun) =.< dlsym dl ("mlx" ++ Data.Char.toUpper (head fun) : tail fun)++-- |Call the Matlab function with the given name in the given library directly+mLibraryCall :: MLibrary -> String -> MFun+mLibraryCall ml f arg no = do+  fun <- mLibraryFun ml f+  fun arg no++foreign import ccall "dynamic" mkFeval :: FunPtr a -> CString -> MLXFun++-- |Internal use only.  See "Foreign.Matlab.Runtime.Generic"+mlGenericFeval :: MLibrary -> IO (CString -> MFun)+mlGenericFeval MLibrary{ mlName = "hsmatlab", mlDL = dl } = do+  fe <- mkFeval =.< dlsym dl "mlHsFeval"+  return $ makeMFun . fe+mlGenericFeval _ = fail "mlGenericEval: use Matlab.Runtime.Generic"

@@ -0,0 +1,80 @@+{-|+  Generic runtime library interface.+  This uses a Matlab library built along with HSMatlab to provide runtime access to general Matlab functionality throuh "Foreign.Matlab.Runtime".+  Any builtin Matlab function can be called through this interface, but other M-file functions may not -- these need to be put into a library or used through "Foreign.Matlab.Engine" instead.+-}+module Foreign.Matlab.Runtime.Generic (+    MLGeneric,+    openMLGeneric,+    closeMLGeneric,+    mlGenericEval,+    mlGenericFun,+    mlGenericSetVar,+    mlGenericGetVar,+    mlGenericCapture+  ) where++import Control.Monad+import Foreign.C.String+--import System.FilePath+import Foreign.Matlab.Util+import Foreign.Matlab.Types+import Foreign.Matlab.Array+import Foreign.Matlab.Runtime+--import Paths_matlab++data MLGeneric = MLGeneric {+    mlgLibrary :: MLibrary,+    mlgFeval :: CString -> MFun+  }++-- |Create a generic interface to the Matlab runtime.  Only one is necessary in any given application.+openMLGeneric :: [String] -> IO MLGeneric+openMLGeneric opt = do+  -- libdir <- getLibDir+  ml <- openMLibrary ({- libdir </> -} "hsmatlab") opt+  feval <- mlGenericFeval ml+  return $ MLGeneric { mlgLibrary = ml, mlgFeval = feval }++-- |Close a MLGeneric interface no longer in use.+closeMLGeneric :: MLGeneric -> IO ()+closeMLGeneric MLGeneric{ mlgLibrary = ml } = closeMLibrary ml++-- |Call the named Matlab function using the specified interface.+mlGenericFun :: MLGeneric -> String -> MFun+mlGenericFun mlg f a n = do+  withCString f (\f -> mlgFeval mlg f (map anyMXArray a) n)++-- |Eval Matlab code.+mlGenericEval :: MLGeneric +  -> String -- ^ The Matlab code string to evaluate+  -> Int -- ^ The number of arguments returned by the code+  -> IO [MAnyArray]+mlGenericEval mlg e n = do+  e <- createRowVector e+  r <- mlGenericFun mlg "eval" [anyMXArray e] n+  freeMXArray e+  return r++-- |Set the given variable to the value in the base scope+mlGenericSetVar :: MLGeneric -> String -> MXArray a -> IO ()+mlGenericSetVar mlg v x = do+  b <- createRowVector "base"+  v <- createRowVector v+  mlGenericFun mlg "assignin" [anyMXArray b,anyMXArray v,anyMXArray x] 0+  freeMXArray v+  freeMXArray b++-- |Get the value of the given variable in the base scope+mlGenericGetVar :: MLGeneric -> String -> IO MAnyArray+mlGenericGetVar mlg v = head =.< mlGenericEval mlg v 1++-- |Evaluate Matlab code and capture the generated output (see 'mlGenericEval')+mlGenericCapture :: MLGeneric -> String -> Int -> IO (String,[MAnyArray])+mlGenericCapture mlg e n = do+  e <- createRowVector e+  (cap:res) <- mlGenericFun mlg "evalc" [anyMXArray e] (succ n)+  freeMXArray e+  Just cap <- castMXArray cap+  cap <- mxArrayGetAll cap+  return $ (cap,res)

@@ -0,0 +1,155 @@+{-|+  Mapping of basic Matlab types to Haskell types.+-}+module Foreign.Matlab.Types (+    -- * Representations of Matlab types+    -- |Most types are simple aliases of Haskell types, given simply to identify them and provide a consistent naming scheme.++    MIO,++    MXClass(..),+    MChar,+    MLogical,+    MScalar,++    MNumeric,+    -- * Numeric types+    MDouble,+    MSingle,+    MInt8,+    MInt16,+    MInt32,+    MInt64,+    MUint8,+    MUint16,+    MUint32,+    MUint64,+    MComplex,++    -- * Array indexing+    MSize, MSubs,+    MIndex(..),+    mStart, mOffset,+    mSizeRange, mRangeSize,+    normMSize, realMSize,++    -- * Opaque types+    MXArray,+    MAnyArray,+    MCell(MCell), mCell,+    MStruct,+    MFun+  ) where++import Data.Complex+import Data.Ix+import Foreign.Matlab.Internal++-- |The class of types which are simple Matlab scalars and can be array elements+class MScalar a+-- |The class of types which Matlab consisters \"numeric\"+class (MScalar a, Num a) => MNumeric a++instance MScalar MChar+instance MScalar MLogical+instance MScalar MDouble+instance MScalar MSingle+instance MScalar MInt8+instance MScalar MInt16+instance MScalar MInt32+instance MScalar MInt64+instance MScalar MUint8+instance MScalar MUint16+instance MScalar MUint32+instance MScalar MUint64+instance MNumeric a => MScalar (MComplex a)++instance MNumeric MDouble+instance MNumeric MSingle+instance MNumeric MInt8+instance MNumeric MInt16+instance MNumeric MInt32+instance MNumeric MInt64+instance MNumeric MUint8+instance MNumeric MUint16+instance MNumeric MUint32+instance MNumeric MUint64++-- |Complex numeric types.  Unfortunately, 'Complex' only applies to 'RealFloat' types, whereas Matlab allows any numeric type, so some types are (currently) unaccessable.+type MComplex = Complex++-- |The type of array sizes, which are the column-major lengths of each dimensions+type MSize = [Int]+-- |The type of array index subscripts, which are the column-major, 0-based indices in each dimension with normal Matlab semantics (flatten along last dimension)+type MSubs = [Int]+-- |Ways to index an array.  Using Matlab semantics, a singleton MSubs [n] is equivalent to a raw 0-based offset (MOffset n).+newtype MIndex = MSubs MSubs+    -- MOffset Int -- ^0-based offset from the beginning of the array (equivalent to singleton MSubs)++-- |First index in array+mStart :: MIndex+mStart = MSubs []++-- |Raw, 0-based array offset index+mOffset :: Int -> MIndex+mOffset i = MSubs [i]++instance Show MIndex where+  showsPrec _ (MSubs []) = id+  showsPrec _ (MSubs l) = showChar '(' . foldr1 (\s r -> s . showChar ',' . r) (map shows l) . showChar ')'+instance Eq MIndex where+  MSubs a == MSubs b = eq a b where+    eq [] [] = True+    eq (x:a) (y:b) = (x == y) && eq a b+    eq [] b = eq [0] b+    eq a [] = eq a [0]+instance Ord MIndex where+  compare (MSubs a) (MSubs b) = cmp a b where+    cmp [] [] = EQ+    cmp (x:a) (y:b) = case cmp a b of { EQ -> compare x y ; r -> r }+    cmp [] b = cmp [0] b+    cmp a [] = cmp a [0]+instance Ix MIndex where+  range (MSubs a, MSubs b) = map MSubs $ rng a b where+    rng [] [] = [[]]+    rng (x:a) (y:b) = concatMap (\l -> map (:l) [x..y]) $ rng a b+    rng [] b = rng [0] b+    rng _ _ = error "MIndex.range: length mismatch"+  index (MSubs a, MSubs b) (MSubs l) = idx a b l where+    idx _ _ [] = 0+    idx (x:a) (y:b) (i:l) = i-x+((y-x+1)*idx a b l)+    idx [] [] (0:l) = idx [] [] l+    idx [] b l = idx [0] b l+    idx _ _ _ = error "MIndex.index: length mismatch"+  inRange (MSubs a, MSubs b) (MSubs l) = inr a b l where+    inr _ _ [] = True+    inr a@(x:_) b@(_:_) [i] = i >= x && i-x < rangeSize (MSubs a, MSubs b)+    inr (x:a) (y:b) (i:l) = i >= x && i <= y && inr a b l+    inr [] [] (0:l) = inr [] [] l+    inr [] b l = inr [0] b l+    inr _ _ _ = error "MIndex.inRange: length mismatch"+  rangeSize (MSubs a, MSubs b) = rsz a b where+    rsz [] b = product $ map succ b+    rsz (x:a) (y:b) = (y-x+1)*rsz a b+    rsz _ _ = error "MIndex.rangeSize: length mismatch"++-- |Convert an array size to an index range, which will be of the form ((0,0,0...),(i-1,j-1,k-1,...))+mSizeRange :: MSize -> (MIndex,MIndex)+mSizeRange l = (MSubs [], MSubs $ map pred $ normMSize l)++-- |Convert an index range to an array size+mRangeSize :: (MIndex,MIndex) -> MSize+mRangeSize (MSubs [], MSubs l) = map succ l+mRangeSize _ = error "mRangeSize: invalid lower bound"++-- |Get the size form that Matlab likes (@length (realMSize s) >= 2@)+realMSize :: MSize -> MSize+realMSize [] = [1,1]+realMSize [n] = [n,1]+realMSize s = s++-- |Get a more useful size form (no trailing singletons)+normMSize :: MSize -> MSize+normMSize [] = []+normMSize (1:l) = case normMSize l of { [] -> [] ; l -> (1:l) }+normMSize (x:l) = x : normMSize l

@@ -0,0 +1,59 @@+module Foreign.Matlab.Util where++import Control.Monad+import Foreign++infixl 1 >., >.=, >=.+infixr 1 =.<, .=<+(>.) :: Monad m => m a -> b -> m b+(>.=) :: Monad m => m a -> (a -> b) -> m b+(=.<) :: Monad m => (a -> b) -> m a -> m b+(>=.) :: Monad m => (a -> m b) -> (b -> c) -> a -> m c+(.=<) :: Monad m => (b -> c) -> (a -> m b) -> a -> m c++(>.) e r = e >> return r+(>.=) e r = e >>= return . r+(=.<) r e = return . r =<< e+(>=.) e r = e >=> return . r+(.=<) r e = return . r <=< e++ii :: (Integral a, Integral b) => a -> b+ii = fromIntegral++type With x y a = x -> (y -> a) -> a++mapWith :: With x y a -> With [x] [y] a+mapWith w l f = m l id where+  m [] s = f (s [])+  m (x:l) s = w x (\y -> m l (s.(y:)))++mapWith' :: With x y a -> With [x] [y] a+mapWith' w = m where+  m [] e = e []+  m (x:l) e = m l (\s -> w x (\y -> e (y:s)))++mapWithRev :: With x y a -> With [x] [y] a+mapWithRev w l f = m l [] where+  m [] s = f s+  m (x:l) s = w x (\y -> m l (y:s))++mapWithArray :: Storable y => With x y (IO a) -> With [x] (Ptr y) (IO a)+mapWithArray w l f = mapWithArrayLen w l (\(p,_) -> f p)++mapWithArrayLen :: Storable y => With x y (IO a) -> With [x] (Ptr y, Int) (IO a)+--mapWithArrayLen w l f = mapWith w l (\l -> withArrayLen l (curry f))+mapWithArrayLen w l f =+  allocaArray (length l) $ \p ->+    let+      set [] i = f (p,i)+      set (x:l) i = w x $ \y -> pokeElemOff p i y >> set l (succ i)+    in set l 0++segment :: Int -> [a] -> [[a]]+segment _ [] = []+segment n l = a : segment n r where (a,r) = splitAt n l++replaceIndex :: [a] -> Int -> a -> [a]+replaceIndex [] _ _ = error "replaceIndex: index too large"+replaceIndex (_:l) 0 y = y:l+replaceIndex (x:l) n y = x : replaceIndex l (pred n) y

@@ -0,0 +1,59 @@+import Distribution.Simple+import Distribution.Simple.Utils+import Distribution.Simple.Setup+import Distribution.Simple.Program+import Distribution.Simple.LocalBuildInfo+import Distribution.PackageDescription+import Distribution.ModuleName (components)+import Control.Monad+import Data.Maybe+import System.Directory+import System.FilePath+defhooks = autoconfUserHooks+programs = [+    simpleProgram "matlab", +    (simpleProgram "mcr") { programFindLocation = \_ -> return Nothing }+  ]+runtime desc = maybe False (elem ["Foreign","Matlab","Runtime"] . map components . exposedModules) $ library desc+postconf args flags desc build = do+  confExists <- doesFileExist "configure"+  unless confExists $ rawSystemExit verb "autoconf" []+  postConf defhooks args flags{ configConfigureArgs = configConfigureArgs flags ++ confargs } desc build+  where +    verb = fromFlag $ configVerbosity flags+    confargs = ("--" ++ (if runtime desc then "enable" else "disable") ++ "-runtime") : map pconfarg pconf+    pconfarg p = "--with-" ++ programId p ++ "=" ++ programPath p ++ " " ++ unwords (programArgs p)+    pconf = mapMaybe (\p -> lookupProgram p (withPrograms build)) programs+build desc binfo hooks flags = do+  when (runtime desc) $ rawSystemExit (fromFlag $ buildVerbosity flags) "make" ["-Csrc"]+  buildHook defhooks desc binfo hooks flags+clean desc binfo hooks flags = do+  makeExists <- doesFileExist "src/Makefile"+  when makeExists $ rawSystemExit (fromFlag $ cleanVerbosity flags) "make" ["-Csrc", "clean"]+  cleanHook defhooks desc binfo hooks flags+install desc binfo hooks flags = do+  instHook defhooks desc binfo hooks flags+  when (runtime desc) $ mapM_ (\f -> +      copyFileVerbose (fromFlag $ installVerbosity flags) +	("src" </> f) +	(libdir (absoluteInstallDirs desc binfo NoCopyDest) </> f))+    ["libhsmatlab.so","libhsmatlab.ctf"]+reg desc binfo hooks flags = do+  pwd <- getCurrentDirectory+  let+    desc' = desc{ library = fmap lm (library desc) }+    lm l = l{ libBuildInfo = (libBuildInfo l)+	{ ldOptions = ("-Wl,-rpath," ++ lib) : ldOptions (libBuildInfo l) } }+    lib+      | fromFlag $ regInPlace flags = pwd </> "src"+      | otherwise = libdir (absoluteInstallDirs desc binfo NoCopyDest)+  regHook defhooks desc' binfo hooks flags+hooks = defhooks {+    hookedPrograms = programs,+    postConf = postconf,+    buildHook = build,+    cleanHook = clean,+    instHook = install,+    regHook = reg+  }+main = defaultMainWithHooks hooks

@@ -0,0 +1,3978 @@+#! /bin/sh+# Guess values for system-dependent variables and create Makefiles.+# Generated by GNU Autoconf 2.61 for Haskell Matlab interface 0.1.+#+# Report bugs to <dylan@dylex.net>.+#+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,+# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.+# This configure script is free software; the Free Software Foundation+# gives unlimited permission to copy, distribute and modify it.+## --------------------- ##+## M4sh Initialization.  ##+## --------------------- ##++# Be 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=:+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+  # is contrary to our usage.  Disable this feature.+  alias -g '${1+"$@"}'='"$@"'+  setopt NO_GLOB_SUBST+else+  case `(set -o) 2>/dev/null` in+  *posix*) set -o posix ;;+esac++fi+++++# PATH needs CR+# Avoid depending upon Character Ranges.+as_cr_letters='abcdefghijklmnopqrstuvwxyz'+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'+as_cr_Letters=$as_cr_letters$as_cr_LETTERS+as_cr_digits='0123456789'+as_cr_alnum=$as_cr_Letters$as_cr_digits++# The user is always right.+if test "${PATH_SEPARATOR+set}" != set; then+  echo "#! /bin/sh" >conf$$.sh+  echo  "exit 0"   >>conf$$.sh+  chmod +x conf$$.sh+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then+    PATH_SEPARATOR=';'+  else+    PATH_SEPARATOR=:+  fi+  rm -f conf$$.sh+fi++# Support unset when possible.+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then+  as_unset=unset+else+  as_unset=false+fi+++# IFS+# We need space, tab and new line, in precisely that order.  Quoting is+# there to prevent editors from complaining about space-tab.+# (If _AS_PATH_WALK were called with IFS unset, it would disable word+# splitting by setting IFS to empty value.)+as_nl='+'+IFS=" ""	$as_nl"++# Find who we are.  Look in the path if we contain no directory separator.+case $0 in+  *[\\/]* ) as_myself=$0 ;;+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break+done+IFS=$as_save_IFS++     ;;+esac+# We did not find ourselves, most probably we were run as `sh COMMAND'+# in which case we are not to be found in the path.+if test "x$as_myself" = x; then+  as_myself=$0+fi+if test ! -f "$as_myself"; then+  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2+  { (exit 1); exit 1; }+fi++# Work around bugs in pre-3.0 UWIN ksh.+for as_var in ENV MAIL MAILPATH+do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+done+PS1='$ '+PS2='> '+PS4='+ '++# NLS nuisances.+for as_var in \+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \+  LC_TELEPHONE LC_TIME+do+  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then+    eval $as_var=C; export $as_var+  else+    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+  fi+done++# Required to use basename.+if expr a : '\(a\)' >/dev/null 2>&1 &&+   test "X`expr 00001 : '.*\(...\)'`" = X001; then+  as_expr=expr+else+  as_expr=false+fi++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then+  as_basename=basename+else+  as_basename=false+fi+++# Name of the executable.+as_me=`$as_basename -- "$0" ||+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \+	 X"$0" : 'X\(//\)$' \| \+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||+echo X/"$0" |+    sed '/^.*\/\([^/][^/]*\)\/*$/{+	    s//\1/+	    q+	  }+	  /^X\/\(\/\/\)$/{+	    s//\1/+	    q+	  }+	  /^X\/\(\/\).*/{+	    s//\1/+	    q+	  }+	  s/.*/./; q'`++# CDPATH.+$as_unset CDPATH+++if test "x$CONFIG_SHELL" = x; then+  if (eval ":") 2>/dev/null; then+  as_have_required=yes+else+  as_have_required=no+fi++  if test $as_have_required = yes && 	 (eval ":+(as_func_return () {+  (exit \$1)+}+as_func_success () {+  as_func_return 0+}+as_func_failure () {+  as_func_return 1+}+as_func_ret_success () {+  return 0+}+as_func_ret_failure () {+  return 1+}++exitcode=0+if as_func_success; then+  :+else+  exitcode=1+  echo as_func_success failed.+fi++if as_func_failure; then+  exitcode=1+  echo as_func_failure succeeded.+fi++if as_func_ret_success; then+  :+else+  exitcode=1+  echo as_func_ret_success failed.+fi++if as_func_ret_failure; then+  exitcode=1+  echo as_func_ret_failure succeeded.+fi++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then+  :+else+  exitcode=1+  echo positional parameters were not saved.+fi++test \$exitcode = 0) || { (exit 1); exit 1; }++(+  as_lineno_1=\$LINENO+  as_lineno_2=\$LINENO+  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&+  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }+") 2> /dev/null; then+  :+else+  as_candidate_shells=+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  case $as_dir in+	 /*)+	   for as_base in sh bash ksh sh5; do+	     as_candidate_shells="$as_candidate_shells $as_dir/$as_base"+	   done;;+       esac+done+IFS=$as_save_IFS+++      for as_shell in $as_candidate_shells $SHELL; do+	 # Try only shells that exist, to save several forks.+	 if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&+		{ ("$as_shell") 2> /dev/null <<\_ASEOF+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+  emulate sh+  NULLCMD=:+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+  # is contrary to our usage.  Disable this feature.+  alias -g '${1+"$@"}'='"$@"'+  setopt NO_GLOB_SUBST+else+  case `(set -o) 2>/dev/null` in+  *posix*) set -o posix ;;+esac++fi+++:+_ASEOF+}; then+  CONFIG_SHELL=$as_shell+	       as_have_required=yes+	       if { "$as_shell" 2> /dev/null <<\_ASEOF+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+  emulate sh+  NULLCMD=:+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+  # is contrary to our usage.  Disable this feature.+  alias -g '${1+"$@"}'='"$@"'+  setopt NO_GLOB_SUBST+else+  case `(set -o) 2>/dev/null` in+  *posix*) set -o posix ;;+esac++fi+++:+(as_func_return () {+  (exit $1)+}+as_func_success () {+  as_func_return 0+}+as_func_failure () {+  as_func_return 1+}+as_func_ret_success () {+  return 0+}+as_func_ret_failure () {+  return 1+}++exitcode=0+if as_func_success; then+  :+else+  exitcode=1+  echo as_func_success failed.+fi++if as_func_failure; then+  exitcode=1+  echo as_func_failure succeeded.+fi++if as_func_ret_success; then+  :+else+  exitcode=1+  echo as_func_ret_success failed.+fi++if as_func_ret_failure; then+  exitcode=1+  echo as_func_ret_failure succeeded.+fi++if ( set x; as_func_ret_success y && test x = "$1" ); then+  :+else+  exitcode=1+  echo positional parameters were not saved.+fi++test $exitcode = 0) || { (exit 1); exit 1; }++(+  as_lineno_1=$LINENO+  as_lineno_2=$LINENO+  test "x$as_lineno_1" != "x$as_lineno_2" &&+  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }++_ASEOF+}; then+  break+fi++fi++      done++      if test "x$CONFIG_SHELL" != x; then+  for as_var in BASH_ENV ENV+        do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+        done+        export CONFIG_SHELL+        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}+fi+++    if test $as_have_required = no; then+  echo This script requires a shell more modern than all the+      echo shells that I found on your system.  Please install a+      echo modern shell, or manually run the script under such a+      echo shell if you do have one.+      { (exit 1); exit 1; }+fi+++fi++fi++++(eval "as_func_return () {+  (exit \$1)+}+as_func_success () {+  as_func_return 0+}+as_func_failure () {+  as_func_return 1+}+as_func_ret_success () {+  return 0+}+as_func_ret_failure () {+  return 1+}++exitcode=0+if as_func_success; then+  :+else+  exitcode=1+  echo as_func_success failed.+fi++if as_func_failure; then+  exitcode=1+  echo as_func_failure succeeded.+fi++if as_func_ret_success; then+  :+else+  exitcode=1+  echo as_func_ret_success failed.+fi++if as_func_ret_failure; then+  exitcode=1+  echo as_func_ret_failure succeeded.+fi++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then+  :+else+  exitcode=1+  echo positional parameters were not saved.+fi++test \$exitcode = 0") || {+  echo No shell found that supports shell functions.+  echo Please tell autoconf@gnu.org about your system,+  echo including any error possibly output before this+  echo message+}++++  as_lineno_1=$LINENO+  as_lineno_2=$LINENO+  test "x$as_lineno_1" != "x$as_lineno_2" &&+  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {++  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO+  # uniformly replaced by the line number.  The first 'sed' inserts a+  # line-number line after each line using $LINENO; the second 'sed'+  # does the real work.  The second script uses 'N' to pair each+  # line-number line with the line containing $LINENO, and appends+  # trailing '-' during substitution so that $LINENO is not a special+  # case at line end.+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the+  # scripts with optimization help from Paolo Bonzini.  Blame Lee+  # E. McMahon (1931-1989) for sed's syntax.  :-)+  sed -n '+    p+    /[$]LINENO/=+  ' <$as_myself |+    sed '+      s/[$]LINENO.*/&-/+      t lineno+      b+      :lineno+      N+      :loop+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/+      t loop+      s/-\n.*//+    ' >$as_me.lineno &&+  chmod +x "$as_me.lineno" ||+    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2+   { (exit 1); exit 1; }; }++  # Don't try to exec as it changes $[0], causing all sort of problems+  # (the dirname of $[0] is not the place where we might find the+  # original and so on.  Autoconf is especially sensitive to this).+  . "./$as_me.lineno"+  # Exit status is that of the last command.+  exit+}+++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then+  as_dirname=dirname+else+  as_dirname=false+fi++ECHO_C= ECHO_N= ECHO_T=+case `echo -n x` in+-n*)+  case `echo 'x\c'` in+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.+  *)   ECHO_C='\c';;+  esac;;+*)+  ECHO_N='-n';;+esac++if expr a : '\(a\)' >/dev/null 2>&1 &&+   test "X`expr 00001 : '.*\(...\)'`" = X001; then+  as_expr=expr+else+  as_expr=false+fi++rm -f conf$$ conf$$.exe conf$$.file+if test -d conf$$.dir; then+  rm -f conf$$.dir/conf$$.file+else+  rm -f conf$$.dir+  mkdir conf$$.dir+fi+echo >conf$$.file+if ln -s conf$$.file conf$$ 2>/dev/null; then+  as_ln_s='ln -s'+  # ... but there are two gotchas:+  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.+  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.+  # In both cases, we have to default to `cp -p'.+  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||+    as_ln_s='cp -p'+elif ln conf$$.file conf$$ 2>/dev/null; then+  as_ln_s=ln+else+  as_ln_s='cp -p'+fi+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file+rmdir conf$$.dir 2>/dev/null++if mkdir -p . 2>/dev/null; then+  as_mkdir_p=:+else+  test -d ./-p && rmdir ./-p+  as_mkdir_p=false+fi++if test -x / >/dev/null 2>&1; then+  as_test_x='test -x'+else+  if ls -dL / >/dev/null 2>&1; then+    as_ls_L_option=L+  else+    as_ls_L_option=+  fi+  as_test_x='+    eval sh -c '\''+      if test -d "$1"; then+        test -d "$1/.";+      else+	case $1 in+        -*)set "./$1";;+	esac;+	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in+	???[sx]*):;;*)false;;esac;fi+    '\'' sh+  '+fi+as_executable_p=$as_test_x++# Sed expression to map a string onto a valid CPP name.+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"++# Sed expression to map a string onto a valid variable name.+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"++++exec 7<&0 </dev/null 6>&1++# Name of the host.+# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,+# so uname gets run too.+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`++#+# Initializations.+#+ac_default_prefix=/usr/local+ac_clean_files=+ac_config_libobj_dir=.+LIBOBJS=+cross_compiling=no+subdirs=+MFLAGS=+MAKEFLAGS=+SHELL=${CONFIG_SHELL-/bin/sh}++# Identity of this package.+PACKAGE_NAME='Haskell Matlab interface'+PACKAGE_TARNAME='haskell-matlab-interface'+PACKAGE_VERSION='0.1'+PACKAGE_STRING='Haskell Matlab interface 0.1'+PACKAGE_BUGREPORT='dylan@dylex.net'++ac_unique_file="matlab.cabal"+ac_subst_vars='SHELL+PATH_SEPARATOR+PACKAGE_NAME+PACKAGE_TARNAME+PACKAGE_VERSION+PACKAGE_STRING+PACKAGE_BUGREPORT+exec_prefix+prefix+program_transform_name+bindir+sbindir+libexecdir+datarootdir+datadir+sysconfdir+sharedstatedir+localstatedir+includedir+oldincludedir+docdir+infodir+htmldir+dvidir+pdfdir+psdir+libdir+localedir+mandir+DEFS+ECHO_C+ECHO_N+ECHO_T+LIBS+build_alias+host_alias+target_alias+MATLAB_BIN+CC+CFLAGS+LDFLAGS+CPPFLAGS+ac_ct_CC+EXEEXT+OBJEXT+MATLAB_MCC+MATLAB_DIR+MATLAB_ARCH+MCCFLAGS+MATLAB_LIB_PATH+MATLAB_LIB_DIR+LIBOBJS+LTLIBOBJS'+ac_subst_files=''+      ac_precious_vars='build_alias+host_alias+target_alias+CC+CFLAGS+LDFLAGS+LIBS+CPPFLAGS'+++# Initialize some variables set by options.+ac_init_help=+ac_init_version=false+# The variables have the same names as the options, with+# dashes changed to underlines.+cache_file=/dev/null+exec_prefix=NONE+no_create=+no_recursion=+prefix=NONE+program_prefix=NONE+program_suffix=NONE+program_transform_name=s,x,x,+silent=+site=+srcdir=+verbose=+x_includes=NONE+x_libraries=NONE++# Installation directory options.+# These are left unexpanded so users can "make install exec_prefix=/foo"+# and all the variables that are supposed to be based on exec_prefix+# by default will actually change.+# Use braces instead of parens because sh, perl, etc. also accept them.+# (The list follows the same order as the GNU Coding Standards.)+bindir='${exec_prefix}/bin'+sbindir='${exec_prefix}/sbin'+libexecdir='${exec_prefix}/libexec'+datarootdir='${prefix}/share'+datadir='${datarootdir}'+sysconfdir='${prefix}/etc'+sharedstatedir='${prefix}/com'+localstatedir='${prefix}/var'+includedir='${prefix}/include'+oldincludedir='/usr/include'+docdir='${datarootdir}/doc/${PACKAGE_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=yes ;;+  esac++  # Accept the important Cygnus configure options, so we can diagnose typos.++  case $ac_dashdash$ac_option in+  --)+    ac_dashdash=yes ;;++  -bindir | --bindir | --bindi | --bind | --bin | --bi)+    ac_prev=bindir ;;+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)+    bindir=$ac_optarg ;;++  -build | --build | --buil | --bui | --bu)+    ac_prev=build_alias ;;+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)+    build_alias=$ac_optarg ;;++  -cache-file | --cache-file | --cache-fil | --cache-fi \+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)+    ac_prev=cache_file ;;+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)+    cache_file=$ac_optarg ;;++  --config-cache | -C)+    cache_file=config.cache ;;++  -datadir | --datadir | --datadi | --datad)+    ac_prev=datadir ;;+  -datadir=* | --datadir=* | --datadi=* | --datad=*)+    datadir=$ac_optarg ;;++  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \+  | --dataroo | --dataro | --datar)+    ac_prev=datarootdir ;;+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)+    datarootdir=$ac_optarg ;;++  -disable-* | --disable-*)+    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`+    # Reject names that are not valid shell variable names.+    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2+   { (exit 1); exit 1; }; }+    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`+    eval enable_$ac_feature=no ;;++  -docdir | --docdir | --docdi | --doc | --do)+    ac_prev=docdir ;;+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)+    docdir=$ac_optarg ;;++  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)+    ac_prev=dvidir ;;+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)+    dvidir=$ac_optarg ;;++  -enable-* | --enable-*)+    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`+    # Reject names that are not valid shell variable names.+    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2+   { (exit 1); exit 1; }; }+    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`+    eval enable_$ac_feature=\$ac_optarg ;;++  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \+  | --exec | --exe | --ex)+    ac_prev=exec_prefix ;;+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \+  | --exec=* | --exe=* | --ex=*)+    exec_prefix=$ac_optarg ;;++  -gas | --gas | --ga | --g)+    # Obsolete; use --with-gas.+    with_gas=yes ;;++  -help | --help | --hel | --he | -h)+    ac_init_help=long ;;+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)+    ac_init_help=recursive ;;+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)+    ac_init_help=short ;;++  -host | --host | --hos | --ho)+    ac_prev=host_alias ;;+  -host=* | --host=* | --hos=* | --ho=*)+    host_alias=$ac_optarg ;;++  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)+    ac_prev=htmldir ;;+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \+  | --ht=*)+    htmldir=$ac_optarg ;;++  -includedir | --includedir | --includedi | --included | --include \+  | --includ | --inclu | --incl | --inc)+    ac_prev=includedir ;;+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \+  | --includ=* | --inclu=* | --incl=* | --inc=*)+    includedir=$ac_optarg ;;++  -infodir | --infodir | --infodi | --infod | --info | --inf)+    ac_prev=infodir ;;+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)+    infodir=$ac_optarg ;;++  -libdir | --libdir | --libdi | --libd)+    ac_prev=libdir ;;+  -libdir=* | --libdir=* | --libdi=* | --libd=*)+    libdir=$ac_optarg ;;++  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \+  | --libexe | --libex | --libe)+    ac_prev=libexecdir ;;+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \+  | --libexe=* | --libex=* | --libe=*)+    libexecdir=$ac_optarg ;;++  -localedir | --localedir | --localedi | --localed | --locale)+    ac_prev=localedir ;;+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)+    localedir=$ac_optarg ;;++  -localstatedir | --localstatedir | --localstatedi | --localstated \+  | --localstate | --localstat | --localsta | --localst | --locals)+    ac_prev=localstatedir ;;+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)+    localstatedir=$ac_optarg ;;++  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)+    ac_prev=mandir ;;+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)+    mandir=$ac_optarg ;;++  -nfp | --nfp | --nf)+    # Obsolete; use --without-fp.+    with_fp=no ;;++  -no-create | --no-create | --no-creat | --no-crea | --no-cre \+  | --no-cr | --no-c | -n)+    no_create=yes ;;++  -no-recursion | --no-recursion | --no-recursio | --no-recursi \+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)+    no_recursion=yes ;;++  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \+  | --oldin | --oldi | --old | --ol | --o)+    ac_prev=oldincludedir ;;+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)+    oldincludedir=$ac_optarg ;;++  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)+    ac_prev=prefix ;;+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)+    prefix=$ac_optarg ;;++  -program-prefix | --program-prefix | --program-prefi | --program-pref \+  | --program-pre | --program-pr | --program-p)+    ac_prev=program_prefix ;;+  -program-prefix=* | --program-prefix=* | --program-prefi=* \+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)+    program_prefix=$ac_optarg ;;++  -program-suffix | --program-suffix | --program-suffi | --program-suff \+  | --program-suf | --program-su | --program-s)+    ac_prev=program_suffix ;;+  -program-suffix=* | --program-suffix=* | --program-suffi=* \+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)+    program_suffix=$ac_optarg ;;++  -program-transform-name | --program-transform-name \+  | --program-transform-nam | --program-transform-na \+  | --program-transform-n | --program-transform- \+  | --program-transform | --program-transfor \+  | --program-transfo | --program-transf \+  | --program-trans | --program-tran \+  | --progr-tra | --program-tr | --program-t)+    ac_prev=program_transform_name ;;+  -program-transform-name=* | --program-transform-name=* \+  | --program-transform-nam=* | --program-transform-na=* \+  | --program-transform-n=* | --program-transform-=* \+  | --program-transform=* | --program-transfor=* \+  | --program-transfo=* | --program-transf=* \+  | --program-trans=* | --program-tran=* \+  | --progr-tra=* | --program-tr=* | --program-t=*)+    program_transform_name=$ac_optarg ;;++  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)+    ac_prev=pdfdir ;;+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)+    pdfdir=$ac_optarg ;;++  -psdir | --psdir | --psdi | --psd | --ps)+    ac_prev=psdir ;;+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)+    psdir=$ac_optarg ;;++  -q | -quiet | --quiet | --quie | --qui | --qu | --q \+  | -silent | --silent | --silen | --sile | --sil)+    silent=yes ;;++  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)+    ac_prev=sbindir ;;+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \+  | --sbi=* | --sb=*)+    sbindir=$ac_optarg ;;++  -sharedstatedir | --sharedstatedir | --sharedstatedi \+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \+  | --sharedst | --shareds | --shared | --share | --shar \+  | --sha | --sh)+    ac_prev=sharedstatedir ;;+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \+  | --sha=* | --sh=*)+    sharedstatedir=$ac_optarg ;;++  -site | --site | --sit)+    ac_prev=site ;;+  -site=* | --site=* | --sit=*)+    site=$ac_optarg ;;++  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)+    ac_prev=srcdir ;;+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)+    srcdir=$ac_optarg ;;++  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \+  | --syscon | --sysco | --sysc | --sys | --sy)+    ac_prev=sysconfdir ;;+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)+    sysconfdir=$ac_optarg ;;++  -target | --target | --targe | --targ | --tar | --ta | --t)+    ac_prev=target_alias ;;+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)+    target_alias=$ac_optarg ;;++  -v | -verbose | --verbose | --verbos | --verbo | --verb)+    verbose=yes ;;++  -version | --version | --versio | --versi | --vers | -V)+    ac_init_version=: ;;++  -with-* | --with-*)+    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`+    # Reject names that are not valid shell variable names.+    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&+      { echo "$as_me: error: invalid package name: $ac_package" >&2+   { (exit 1); exit 1; }; }+    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`+    eval with_$ac_package=\$ac_optarg ;;++  -without-* | --without-*)+    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`+    # Reject names that are not valid shell variable names.+    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&+      { echo "$as_me: error: invalid package name: $ac_package" >&2+   { (exit 1); exit 1; }; }+    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`+    eval with_$ac_package=no ;;++  --x)+    # Obsolete; use --with-x.+    with_x=yes ;;++  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \+  | --x-incl | --x-inc | --x-in | --x-i)+    ac_prev=x_includes ;;+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)+    x_includes=$ac_optarg ;;++  -x-libraries | --x-libraries | --x-librarie | --x-librari \+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)+    ac_prev=x_libraries ;;+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)+    x_libraries=$ac_optarg ;;++  -*) { echo "$as_me: error: unrecognized option: $ac_option+Try \`$0 --help' for more information." >&2+   { (exit 1); exit 1; }; }+    ;;++  *=*)+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`+    # Reject names that are not valid shell variable names.+    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&+      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2+   { (exit 1); exit 1; }; }+    eval $ac_envvar=\$ac_optarg+    export $ac_envvar ;;++  *)+    # FIXME: should be removed in autoconf 3.0.+    echo "$as_me: WARNING: you should use --build, --host, --target" >&2+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&+      echo "$as_me: WARNING: invalid host type: $ac_option" >&2+    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}+    ;;++  esac+done++if test -n "$ac_prev"; then+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`+  { echo "$as_me: error: missing argument to $ac_option" >&2+   { (exit 1); exit 1; }; }+fi++# Be sure to have absolute directory names.+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \+		datadir sysconfdir sharedstatedir localstatedir includedir \+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \+		libdir localedir mandir+do+  eval ac_val=\$$ac_var+  case $ac_val in+    [\\/$]* | ?:[\\/]* )  continue;;+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;+  esac+  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2+   { (exit 1); exit 1; }; }+done++# There might be people who depend on the old broken behavior: `$host'+# used to hold the argument of --host etc.+# FIXME: To remove some day.+build=$build_alias+host=$host_alias+target=$target_alias++# FIXME: To remove some day.+if test "x$host_alias" != x; then+  if test "x$build_alias" = x; then+    cross_compiling=maybe+    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.+    If a cross compiler is detected then cross compile mode will be used." >&2+  elif test "x$build_alias" != "x$host_alias"; then+    cross_compiling=yes+  fi+fi++ac_tool_prefix=+test -n "$host_alias" && ac_tool_prefix=$host_alias-++test "$silent" = yes && exec 6>/dev/null+++ac_pwd=`pwd` && test -n "$ac_pwd" &&+ac_ls_di=`ls -di .` &&+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||+  { echo "$as_me: error: Working directory cannot be determined" >&2+   { (exit 1); exit 1; }; }+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||+  { echo "$as_me: error: pwd does not report name of working directory" >&2+   { (exit 1); exit 1; }; }+++# Find the source files, if location was not specified.+if test -z "$srcdir"; then+  ac_srcdir_defaulted=yes+  # Try the directory containing this script, then the parent directory.+  ac_confdir=`$as_dirname -- "$0" ||+$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+	 X"$0" : 'X\(//\)[^/]' \| \+	 X"$0" : 'X\(//\)$' \| \+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||+echo X"$0" |+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{+	    s//\1/+	    q+	  }+	  /^X\(\/\/\)[^/].*/{+	    s//\1/+	    q+	  }+	  /^X\(\/\/\)$/{+	    s//\1/+	    q+	  }+	  /^X\(\/\).*/{+	    s//\1/+	    q+	  }+	  s/.*/./; q'`+  srcdir=$ac_confdir+  if test ! -r "$srcdir/$ac_unique_file"; then+    srcdir=..+  fi+else+  ac_srcdir_defaulted=no+fi+if test ! -r "$srcdir/$ac_unique_file"; then+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."+  { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2+   { (exit 1); exit 1; }; }+fi+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"+ac_abs_confdir=`(+	cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2+   { (exit 1); exit 1; }; }+	pwd)`+# When building in place, set srcdir=.+if test "$ac_abs_confdir" = "$ac_pwd"; then+  srcdir=.+fi+# Remove unnecessary trailing slashes from srcdir.+# Double slashes in file names in object file debugging info+# mess up M-x gdb in Emacs.+case $srcdir in+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;+esac+for ac_var in $ac_precious_vars; do+  eval ac_env_${ac_var}_set=\${${ac_var}+set}+  eval ac_env_${ac_var}_value=\$${ac_var}+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}+  eval ac_cv_env_${ac_var}_value=\$${ac_var}+done++#+# Report the --help message.+#+if test "$ac_init_help" = "long"; then+  # Omit some internal or obsolete options to make the list less imposing.+  # This message is too long to be a string in the A/UX 3.1 sh.+  cat <<_ACEOF+\`configure' configures Haskell Matlab interface 0.1 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/haskell-matlab-interface]+  --htmldir=DIR          html documentation [DOCDIR]+  --dvidir=DIR           dvi documentation [DOCDIR]+  --pdfdir=DIR           pdf documentation [DOCDIR]+  --psdir=DIR            ps documentation [DOCDIR]+_ACEOF++  cat <<\_ACEOF+_ACEOF+fi++if test -n "$ac_init_help"; then+  case $ac_init_help in+     short | recursive ) echo "Configuration of Haskell Matlab interface 0.1:";;+   esac+  cat <<\_ACEOF++Optional Features:+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]+  --disable-runtime       enable Matlab.Runtime interface [default=yes]++Optional Packages:+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)+  --with-mcr=PATH         use Matlab Component Runtime installed in PATH+                          [default=no]+  --with-matlab=MATLAB    use specified matlab [default=check]++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    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if+              you have headers in a nonstandard directory <include dir>++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 <dylan@dylex.net>.+_ACEOF+ac_status=$?+fi++if test "$ac_init_help" = "recursive"; then+  # If there are subdirs, report their specific --help.+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue+    test -d "$ac_dir" || continue+    ac_builddir=.++case "$ac_dir" in+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;+*)+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`+  # A ".." for each directory in $ac_dir_suffix.+  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`+  case $ac_top_builddir_sub in+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;+  esac ;;+esac+ac_abs_top_builddir=$ac_pwd+ac_abs_builddir=$ac_pwd$ac_dir_suffix+# for backward compatibility:+ac_top_builddir=$ac_top_build_prefix++case $srcdir in+  .)  # We are building in place.+    ac_srcdir=.+    ac_top_srcdir=$ac_top_builddir_sub+    ac_abs_top_srcdir=$ac_pwd ;;+  [\\/]* | ?:[\\/]* )  # Absolute name.+    ac_srcdir=$srcdir$ac_dir_suffix;+    ac_top_srcdir=$srcdir+    ac_abs_top_srcdir=$srcdir ;;+  *) # Relative name.+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix+    ac_top_srcdir=$ac_top_build_prefix$srcdir+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;+esac+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix++    cd "$ac_dir" || { ac_status=$?; continue; }+    # Check for guested configure.+    if test -f "$ac_srcdir/configure.gnu"; then+      echo &&+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive+    elif test -f "$ac_srcdir/configure"; then+      echo &&+      $SHELL "$ac_srcdir/configure" --help=recursive+    else+      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2+    fi || ac_status=$?+    cd "$ac_pwd" || { ac_status=$?; break; }+  done+fi++test -n "$ac_init_help" && exit $ac_status+if $ac_init_version; then+  cat <<\_ACEOF+Haskell Matlab interface configure 0.1+generated by GNU Autoconf 2.61++Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,+2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.+This configure script is free software; the Free Software Foundation+gives unlimited permission to copy, distribute and modify it.+_ACEOF+  exit+fi+cat >config.log <<_ACEOF+This file contains any messages produced by compilers while+running configure, to aid debugging if configure makes a mistake.++It was created by Haskell Matlab interface $as_me 0.1, which was+generated by GNU Autoconf 2.61.  Invocation command line was++  $ $0 $@++_ACEOF+exec 5>>config.log+{+cat <<_ASUNAME+## --------- ##+## Platform. ##+## --------- ##++hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`+uname -m = `(uname -m) 2>/dev/null || echo unknown`+uname -r = `(uname -r) 2>/dev/null || echo unknown`+uname -s = `(uname -s) 2>/dev/null || echo unknown`+uname -v = `(uname -v) 2>/dev/null || echo unknown`++/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`++/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`++_ASUNAME++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  echo "PATH: $as_dir"+done+IFS=$as_save_IFS++} >&5++cat >&5 <<_ACEOF+++## ----------- ##+## Core tests. ##+## ----------- ##++_ACEOF+++# Keep a trace of the command line.+# Strip out --no-create and --no-recursion so they do not pile up.+# Strip out --silent because we don't want to record it for future runs.+# Also quote any args containing shell meta-characters.+# Make two passes to allow for proper duplicate-argument suppression.+ac_configure_args=+ac_configure_args0=+ac_configure_args1=+ac_must_keep_next=false+for ac_pass in 1 2+do+  for ac_arg+  do+    case $ac_arg in+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \+    | -silent | --silent | --silen | --sile | --sil)+      continue ;;+    *\'*)+      ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;+    esac+    case $ac_pass in+    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;+    2)+      ac_configure_args1="$ac_configure_args1 '$ac_arg'"+      if test $ac_must_keep_next = true; then+	ac_must_keep_next=false # Got value, back to normal.+      else+	case $ac_arg in+	  *=* | --config-cache | -C | -disable-* | --disable-* \+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \+	  | -with-* | --with-* | -without-* | --without-* | --x)+	    case "$ac_configure_args0 " in+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;+	    esac+	    ;;+	  -* ) ac_must_keep_next=true ;;+	esac+      fi+      ac_configure_args="$ac_configure_args '$ac_arg'"+      ;;+    esac+  done+done+$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }+$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }++# When interrupted or exit'd, cleanup temporary files, and complete+# config.log.  We remove comments because anyway the quotes in there+# would cause problems or look ugly.+# WARNING: Use '\'' to represent an apostrophe within the trap.+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.+trap 'exit_status=$?+  # Save into config.log some information that might help in debugging.+  {+    echo++    cat <<\_ASBOX+## ---------------- ##+## Cache variables. ##+## ---------------- ##+_ASBOX+    echo+    # The following way of writing the cache mishandles newlines in values,+(+  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do+    eval ac_val=\$$ac_var+    case $ac_val in #(+    *${as_nl}*)+      case $ac_var in #(+      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5+echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;+      esac+      case $ac_var in #(+      _ | IFS | as_nl) ;; #(+      *) $as_unset $ac_var ;;+      esac ;;+    esac+  done+  (set) 2>&1 |+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(+    *${as_nl}ac_space=\ *)+      sed -n \+	"s/'\''/'\''\\\\'\'''\''/g;+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"+      ;; #(+    *)+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"+      ;;+    esac |+    sort+)+    echo++    cat <<\_ASBOX+## ----------------- ##+## Output variables. ##+## ----------------- ##+_ASBOX+    echo+    for ac_var in $ac_subst_vars+    do+      eval ac_val=\$$ac_var+      case $ac_val in+      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;+      esac+      echo "$ac_var='\''$ac_val'\''"+    done | sort+    echo++    if test -n "$ac_subst_files"; then+      cat <<\_ASBOX+## ------------------- ##+## File substitutions. ##+## ------------------- ##+_ASBOX+      echo+      for ac_var in $ac_subst_files+      do+	eval ac_val=\$$ac_var+	case $ac_val in+	*\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;+	esac+	echo "$ac_var='\''$ac_val'\''"+      done | sort+      echo+    fi++    if test -s confdefs.h; then+      cat <<\_ASBOX+## ----------- ##+## confdefs.h. ##+## ----------- ##+_ASBOX+      echo+      cat confdefs.h+      echo+    fi+    test "$ac_signal" != 0 &&+      echo "$as_me: caught signal $ac_signal"+    echo "$as_me: exit $exit_status"+  } >&5+  rm -f core *.core core.conftest.* &&+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&+    exit $exit_status+' 0+for ac_signal in 1 2 13 15; do+  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal+done+ac_signal=0++# confdefs.h avoids OS command line length limits that DEFS can exceed.+rm -f -r conftest* confdefs.h++# Predefined preprocessor variables.++cat >>confdefs.h <<_ACEOF+#define PACKAGE_NAME "$PACKAGE_NAME"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_VERSION "$PACKAGE_VERSION"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_STRING "$PACKAGE_STRING"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"+_ACEOF+++# Let the site file select an alternate cache file if it wants to.+# Prefer explicitly selected file to automatically selected ones.+if test -n "$CONFIG_SITE"; then+  set x "$CONFIG_SITE"+elif test "x$prefix" != xNONE; then+  set x "$prefix/share/config.site" "$prefix/etc/config.site"+else+  set x "$ac_default_prefix/share/config.site" \+	"$ac_default_prefix/etc/config.site"+fi+shift+for ac_site_file+do+  if test -r "$ac_site_file"; then+    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5+echo "$as_me: loading site script $ac_site_file" >&6;}+    sed 's/^/| /' "$ac_site_file" >&5+    . "$ac_site_file"+  fi+done++if test -r "$cache_file"; then+  # Some versions of bash will fail to source /dev/null (special+  # files actually), so we avoid doing that.+  if test -f "$cache_file"; then+    { echo "$as_me:$LINENO: loading cache $cache_file" >&5+echo "$as_me: loading cache $cache_file" >&6;}+    case $cache_file in+      [\\/]* | ?:[\\/]* ) . "$cache_file";;+      *)                      . "./$cache_file";;+    esac+  fi+else+  { echo "$as_me:$LINENO: creating cache $cache_file" >&5+echo "$as_me: creating cache $cache_file" >&6;}+  >$cache_file+fi++# Check that the precious variables saved in the cache have kept the same+# value.+ac_cache_corrupted=false+for ac_var in $ac_precious_vars; do+  eval ac_old_set=\$ac_cv_env_${ac_var}_set+  eval ac_new_set=\$ac_env_${ac_var}_set+  eval ac_old_val=\$ac_cv_env_${ac_var}_value+  eval ac_new_val=\$ac_env_${ac_var}_value+  case $ac_old_set,$ac_new_set in+    set,)+      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5+echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}+      ac_cache_corrupted=: ;;+    ,set)+      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5+echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}+      ac_cache_corrupted=: ;;+    ,);;+    *)+      if test "x$ac_old_val" != "x$ac_new_val"; then+	{ echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5+echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}+	{ echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5+echo "$as_me:   former value:  $ac_old_val" >&2;}+	{ echo "$as_me:$LINENO:   current value: $ac_new_val" >&5+echo "$as_me:   current value: $ac_new_val" >&2;}+	ac_cache_corrupted=:+      fi;;+  esac+  # Pass precious variables to config.status.+  if test "$ac_new_set" = set; then+    case $ac_new_val in+    *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;+    *) ac_arg=$ac_var=$ac_new_val ;;+    esac+    case " $ac_configure_args " in+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.+      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;+    esac+  fi+done+if $ac_cache_corrupted; then+  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5+echo "$as_me: error: changes in the environment can compromise the build" >&2;}+  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5+echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}+   { (exit 1); exit 1; }; }+fi++++++++++++++++++++++++++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+++++# Check whether --with-mcr was given.+if test "${with_mcr+set}" = set; then+  withval=$with_mcr;+else+  with_mcr=+fi+++# Check whether --with-matlab was given.+if test "${with_matlab+set}" = set; then+  withval=$with_matlab;+else+  with_matlab=yes+fi++# Check whether --enable-runtime was given.+if test "${enable_runtime+set}" = set; then+  enableval=$enable_runtime; use_runtime=$enableval+else+  use_runtime=yes+fi++++if test "$with_matlab" == yes; then+  # Extract the first word of "matlab", so it can be a program name with args.+set dummy matlab; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_path_MATLAB_BIN+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  case $MATLAB_BIN in+  [\\/]* | ?:[\\/]*)+  ac_cv_path_MATLAB_BIN="$MATLAB_BIN" # 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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+    ac_cv_path_MATLAB_BIN="$as_dir/$ac_word$ac_exec_ext"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done+IFS=$as_save_IFS++  ;;+esac+fi+MATLAB_BIN=$ac_cv_path_MATLAB_BIN+if test -n "$MATLAB_BIN"; then+  { echo "$as_me:$LINENO: result: $MATLAB_BIN" >&5+echo "${ECHO_T}$MATLAB_BIN" >&6; }+else+  { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++elif test "$with_matlab" != no; then+  MATLAB_BIN="$with_matlab"+fi+++if test -n "$with_mcr"; then+++{ echo "$as_me:$LINENO: checking Matlab Component Runtime" >&5+echo $ECHO_N "checking Matlab Component Runtime... $ECHO_C" >&6; }+if test \! -d "$with_mcr/runtime"; then++       { echo "$as_me:$LINENO: result: not found" >&5+echo "${ECHO_T}not found" >&6; }+       { { echo "$as_me:$LINENO: error: Matlab Component Runtime not found at $with_mcr/runtime+See \`config.log' for more details." >&5+echo "$as_me: error: Matlab Component Runtime not found at $with_mcr/runtime+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }+fi++{ echo "$as_me:$LINENO: result: $with_mcr" >&5+echo "${ECHO_T}$with_mcr" >&6; }+MATLAB_DIR="$with_mcr"+MATLAB_ARCH=`ls $MATLAB_DIR/runtime 2>/dev/null`+MATLAB_LIB_PATH="$MATLAB_DIR/bin/$MATLAB_ARCH"+++else+++if test -z "$MATLAB_BIN"; then+  { { echo "$as_me:$LINENO: error: Matlab is required" >&5+echo "$as_me: error: Matlab is required" >&2;}+   { (exit 1); exit 1; }; }+fi+++{ echo "$as_me:$LINENO: checking matlab environment" >&5+echo $ECHO_N "checking matlab environment... $ECHO_C" >&6; }++matlab_env=./matlab.env+env -i $MATLAB_BIN -e > $matlab_env 2>&5+matlab_envres=$?+cat $matlab_env >&5++++unset MATLAB+if test $matlab_envres -gt 0; then+  { echo "$as_me:$LINENO: result: failed" >&5+echo "${ECHO_T}failed" >&6; }+      { { echo "$as_me:$LINENO: error: $MATLAB_BIN -e failed+See \`config.log' for more details." >&5+echo "$as_me: error: $MATLAB_BIN -e failed+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }+elif ! (. $matlab_env > /dev/null 2>&1 && test -n "$MATLAB"); then+  { echo "$as_me:$LINENO: result: invalid" >&5+echo "${ECHO_T}invalid" >&6; }+      { { echo "$as_me:$LINENO: error: $MATLAB_BIN -e output invalid+See \`config.log' for more details." >&5+echo "$as_me: error: $MATLAB_BIN -e output invalid+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }+else+  { echo "$as_me:$LINENO: result: `. $matlab_env && echo "${MATLAB}"`" >&5+echo "${ECHO_T}`. $matlab_env && echo "${MATLAB}"`" >&6; }+fi+++MATLAB_DIR=`. $matlab_env && echo "${MATLAB}"`+MATLAB_ARCH=`. $matlab_env && echo "${ARCH}"`+MATLAB_LIB_PATH=`. $matlab_env && echo "${LD_LIBRARY_PATH//:/ }"`+++fi+++{ echo "$as_me:$LINENO: checking matlab arch" >&5+echo $ECHO_N "checking matlab arch... $ECHO_C" >&6; }+case "$MATLAB_ARCH" in+  sol64|sola64|glnx86|glnxi64|glnxa64|mac|maci) { echo "$as_me:$LINENO: result: $MATLAB_ARCH" >&5+echo "${ECHO_T}$MATLAB_ARCH" >&6; } ;;+  *) { echo "$as_me:$LINENO: result: unknown" >&5+echo "${ECHO_T}unknown" >&6; }+	MATLAB_ARCH= ;;+esac++if test -z "$MATLAB_ARCH"; then+  { { echo "$as_me:$LINENO: error: matlab architecture unknown+See \`config.log' for more details." >&5+echo "$as_me: error: matlab architecture unknown+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }+fi+++MATLAB_LIB_DIR="$MATLAB_DIR/bin/$MATLAB_ARCH"++LDFLAGS="$LDFLAGS -Wl,-rpath,$MATLAB_LIB_DIR"+save_ldflags="$LDFLAGS"+LDFLAGS="$LDFLAGS -L${MATLAB_LIB_PATH// / -L}"+ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+if test -n "$ac_tool_prefix"; then+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.+set dummy ${ac_tool_prefix}gcc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$CC"; then+  ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+    ac_cv_prog_CC="${ac_tool_prefix}gcc"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done+IFS=$as_save_IFS++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+  { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+  { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++fi+if test -z "$ac_cv_prog_CC"; then+  ac_ct_CC=$CC+  # Extract the first word of "gcc", so it can be a program name with args.+set dummy gcc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$ac_ct_CC"; then+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+    ac_cv_prog_ac_ct_CC="gcc"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done+IFS=$as_save_IFS++fi+fi+ac_ct_CC=$ac_cv_prog_ac_ct_CC+if test -n "$ac_ct_CC"; then+  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5+echo "${ECHO_T}$ac_ct_CC" >&6; }+else+  { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi++  if test "x$ac_ct_CC" = x; then+    CC=""+  else+    case $cross_compiling:$ac_tool_warned in+yes:)+{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet.  If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&5+echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet.  If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&2;}+ac_tool_warned=yes ;;+esac+    CC=$ac_ct_CC+  fi+else+  CC="$ac_cv_prog_CC"+fi++if test -z "$CC"; then+          if test -n "$ac_tool_prefix"; then+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.+set dummy ${ac_tool_prefix}cc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$CC"; then+  ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+    ac_cv_prog_CC="${ac_tool_prefix}cc"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done+IFS=$as_save_IFS++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+  { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+  { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++  fi+fi+if test -z "$CC"; then+  # Extract the first word of "cc", so it can be a program name with args.+set dummy cc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$CC"; then+  ac_cv_prog_CC="$CC" # Let the user override the test.+else+  ac_prog_rejected=no+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then+       ac_prog_rejected=yes+       continue+     fi+    ac_cv_prog_CC="cc"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done+IFS=$as_save_IFS++if test $ac_prog_rejected = yes; then+  # We found a bogon in the path, so make sure we never use it.+  set dummy $ac_cv_prog_CC+  shift+  if test $# != 0; then+    # We chose a different compiler from the bogus one.+    # However, it has the same basename, so the bogon will be chosen+    # first if we set CC to just the basename; use the full file name.+    shift+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"+  fi+fi+fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+  { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+  { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++fi+if test -z "$CC"; then+  if test -n "$ac_tool_prefix"; then+  for ac_prog in cl.exe+  do+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.+set dummy $ac_tool_prefix$ac_prog; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$CC"; then+  ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done+IFS=$as_save_IFS++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+  { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+  { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++    test -n "$CC" && break+  done+fi+if test -z "$CC"; then+  ac_ct_CC=$CC+  for ac_prog in cl.exe+do+  # Extract the first word of "$ac_prog", so it can be a program name with args.+set dummy $ac_prog; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$ac_ct_CC"; then+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+    ac_cv_prog_ac_ct_CC="$ac_prog"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done+IFS=$as_save_IFS++fi+fi+ac_ct_CC=$ac_cv_prog_ac_ct_CC+if test -n "$ac_ct_CC"; then+  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5+echo "${ECHO_T}$ac_ct_CC" >&6; }+else+  { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++  test -n "$ac_ct_CC" && break+done++  if test "x$ac_ct_CC" = x; then+    CC=""+  else+    case $cross_compiling:$ac_tool_warned in+yes:)+{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet.  If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&5+echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet.  If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&2;}+ac_tool_warned=yes ;;+esac+    CC=$ac_ct_CC+  fi+fi++fi+++test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH+See \`config.log' for more details." >&5+echo "$as_me: error: no acceptable C compiler found in \$PATH+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }++# Provide some information about the compiler.+echo "$as_me:$LINENO: checking for C compiler version" >&5+ac_compiler=`set X $ac_compile; echo $2`+{ (ac_try="$ac_compiler --version >&5"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_compiler --version >&5") 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }+{ (ac_try="$ac_compiler -v >&5"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_compiler -v >&5") 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }+{ (ac_try="$ac_compiler -V >&5"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_compiler -V >&5") 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }++cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++int+main ()+{++  ;+  return 0;+}+_ACEOF+ac_clean_files_save=$ac_clean_files+ac_clean_files="$ac_clean_files a.out a.exe b.out"+# Try to create an executable without -o first, disregard a.out.+# It will help us diagnose broken compilers, and finding out an intuition+# of exeext.+{ echo "$as_me:$LINENO: checking for C compiler default output file name" >&5+echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6; }+ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`+#+# List of possible output files, starting from the most likely.+# The algorithm is not robust to junk in `.', hence go to wildcards (a.*)+# only as a last resort.  b.out is created by i960 compilers.+ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out'+#+# The IRIX 6 linker writes into existing files which may not be+# executable, retaining their permissions.  Remove them first so a+# subsequent execution test works.+ac_rmfiles=+for ac_file in $ac_files+do+  case $ac_file in+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;+  esac+done+rm -f $ac_rmfiles++if { (ac_try="$ac_link_default"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_link_default") 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; then+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'+# in a Makefile.  We should not override ac_cv_exeext if it was cached,+# so that the user can short-circuit this test for compilers unknown to+# Autoconf.+for ac_file in $ac_files ''+do+  test -f "$ac_file" || continue+  case $ac_file in+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj )+	;;+    [ab].out )+	# We found the default executable, but exeext='' is most+	# certainly right.+	break;;+    *.* )+        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;+	then :; else+	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`+	fi+	# We set ac_cv_exeext here because the later test for it is not+	# safe: cross compilers may not add the suffix if given an `-o'+	# argument, so we may need to know it at that point already.+	# Even if this section looks crufty: it has the advantage of+	# actually working.+	break;;+    * )+	break;;+  esac+done+test "$ac_cv_exeext" = no && ac_cv_exeext=++else+  ac_file=''+fi++{ echo "$as_me:$LINENO: result: $ac_file" >&5+echo "${ECHO_T}$ac_file" >&6; }+if test -z "$ac_file"; then+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++{ { echo "$as_me:$LINENO: error: C compiler cannot create executables+See \`config.log' for more details." >&5+echo "$as_me: error: C compiler cannot create executables+See \`config.log' for more details." >&2;}+   { (exit 77); exit 77; }; }+fi++ac_exeext=$ac_cv_exeext++# Check that the compiler produces executables we can run.  If not, either+# the compiler is broken, or we cross compile.+{ echo "$as_me:$LINENO: checking whether the C compiler works" >&5+echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6; }+# FIXME: These cross compiler hacks should be removed for Autoconf 3.0+# If not cross compiling, check that we can run a simple program.+if test "$cross_compiling" != yes; then+  if { ac_try='./$ac_file'+  { (case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_try") 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+    cross_compiling=no+  else+    if test "$cross_compiling" = maybe; then+	cross_compiling=yes+    else+	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.+If you meant to cross compile, use \`--host'.+See \`config.log' for more details." >&5+echo "$as_me: error: cannot run C compiled programs.+If you meant to cross compile, use \`--host'.+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }+    fi+  fi+fi+{ echo "$as_me:$LINENO: result: yes" >&5+echo "${ECHO_T}yes" >&6; }++rm -f a.out a.exe conftest$ac_cv_exeext b.out+ac_clean_files=$ac_clean_files_save+# Check that the compiler produces executables we can run.  If not, either+# the compiler is broken, or we cross compile.+{ echo "$as_me:$LINENO: checking whether we are cross compiling" >&5+echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; }+{ echo "$as_me:$LINENO: result: $cross_compiling" >&5+echo "${ECHO_T}$cross_compiling" >&6; }++{ echo "$as_me:$LINENO: checking for suffix of executables" >&5+echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; }+if { (ac_try="$ac_link"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_link") 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; then+  # If both `conftest.exe' and `conftest' are `present' (well, observable)+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will+# work properly (i.e., refer to `conftest.exe'), while it won't with+# `rm'.+for ac_file in conftest.exe conftest conftest.*; do+  test -f "$ac_file" || continue+  case $ac_file in+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`+	  break;;+    * ) break;;+  esac+done+else+  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link+See \`config.log' for more details." >&5+echo "$as_me: error: cannot compute suffix of executables: cannot compile and link+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }+fi++rm -f conftest$ac_cv_exeext+{ echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5+echo "${ECHO_T}$ac_cv_exeext" >&6; }++rm -f conftest.$ac_ext+EXEEXT=$ac_cv_exeext+ac_exeext=$EXEEXT+{ echo "$as_me:$LINENO: checking for suffix of object files" >&5+echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; }+if test "${ac_cv_objext+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++int+main ()+{++  ;+  return 0;+}+_ACEOF+rm -f conftest.o conftest.obj+if { (ac_try="$ac_compile"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_compile") 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; then+  for ac_file in conftest.o conftest.obj conftest.*; do+  test -f "$ac_file" || continue;+  case $ac_file in+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;;+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`+       break;;+  esac+done+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile+See \`config.log' for more details." >&5+echo "$as_me: error: cannot compute suffix of object files: cannot compile+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }+fi++rm -f conftest.$ac_cv_objext conftest.$ac_ext+fi+{ echo "$as_me:$LINENO: result: $ac_cv_objext" >&5+echo "${ECHO_T}$ac_cv_objext" >&6; }+OBJEXT=$ac_cv_objext+ac_objext=$OBJEXT+{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5+echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }+if test "${ac_cv_c_compiler_gnu+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++int+main ()+{+#ifndef __GNUC__+       choke me+#endif++  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_compile") 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } && {+	 test -z "$ac_c_werror_flag" ||+	 test ! -s conftest.err+       } && test -s conftest.$ac_objext; then+  ac_compiler_gnu=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++	ac_compiler_gnu=no+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+ac_cv_c_compiler_gnu=$ac_compiler_gnu++fi+{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5+echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }+GCC=`test $ac_compiler_gnu = yes && echo yes`+ac_test_CFLAGS=${CFLAGS+set}+ac_save_CFLAGS=$CFLAGS+{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5+echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }+if test "${ac_cv_prog_cc_g+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  ac_save_c_werror_flag=$ac_c_werror_flag+   ac_c_werror_flag=yes+   ac_cv_prog_cc_g=no+   CFLAGS="-g"+   cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++int+main ()+{++  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_compile") 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } && {+	 test -z "$ac_c_werror_flag" ||+	 test ! -s conftest.err+       } && test -s conftest.$ac_objext; then+  ac_cv_prog_cc_g=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++	CFLAGS=""+      cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++int+main ()+{++  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_compile") 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } && {+	 test -z "$ac_c_werror_flag" ||+	 test ! -s conftest.err+       } && test -s conftest.$ac_objext; then+  :+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++	ac_c_werror_flag=$ac_save_c_werror_flag+	 CFLAGS="-g"+	 cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++int+main ()+{++  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_compile") 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } && {+	 test -z "$ac_c_werror_flag" ||+	 test ! -s conftest.err+       } && test -s conftest.$ac_objext; then+  ac_cv_prog_cc_g=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5+++fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+   ac_c_werror_flag=$ac_save_c_werror_flag+fi+{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5+echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }+if test "$ac_test_CFLAGS" = set; then+  CFLAGS=$ac_save_CFLAGS+elif test $ac_cv_prog_cc_g = yes; then+  if test "$GCC" = yes; then+    CFLAGS="-g -O2"+  else+    CFLAGS="-g"+  fi+else+  if test "$GCC" = yes; then+    CFLAGS="-O2"+  else+    CFLAGS=+  fi+fi+{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5+echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }+if test "${ac_cv_prog_cc_c89+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  ac_cv_prog_cc_c89=no+ac_save_CC=$CC+cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <stdarg.h>+#include <stdio.h>+#include <sys/types.h>+#include <sys/stat.h>+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */+struct buf { int x; };+FILE * (*rcsopen) (struct buf *, struct stat *, int);+static char *e (p, i)+     char **p;+     int i;+{+  return p[i];+}+static char *f (char * (*g) (char **, int), char **p, ...)+{+  char *s;+  va_list v;+  va_start (v,p);+  s = g (p, va_arg (v,int));+  va_end (v);+  return s;+}++/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has+   function prototypes and stuff, but not '\xHH' hex character constants.+   These don't provoke an error unfortunately, instead are silently treated+   as 'x'.  The following induces an error, until -std is added to get+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an+   array size at least.  It's necessary to write '\x00'==0 to get something+   that's true only with -std.  */+int osf4_cc_array ['\x00' == 0 ? 1 : -1];++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters+   inside strings and character constants.  */+#define FOO(x) 'x'+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];++int test (int i, double x);+struct s1 {int (*f) (int a);};+struct s2 {int (*f) (double a);};+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);+int argc;+char **argv;+int+main ()+{+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];+  ;+  return 0;+}+_ACEOF+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"+do+  CC="$ac_save_CC $ac_arg"+  rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_compile") 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } && {+	 test -z "$ac_c_werror_flag" ||+	 test ! -s conftest.err+       } && test -s conftest.$ac_objext; then+  ac_cv_prog_cc_c89=$ac_arg+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5+++fi++rm -f core conftest.err conftest.$ac_objext+  test "x$ac_cv_prog_cc_c89" != "xno" && break+done+rm -f conftest.$ac_ext+CC=$ac_save_CC++fi+# AC_CACHE_VAL+case "x$ac_cv_prog_cc_c89" in+  x)+    { echo "$as_me:$LINENO: result: none needed" >&5+echo "${ECHO_T}none needed" >&6; } ;;+  xno)+    { echo "$as_me:$LINENO: result: unsupported" >&5+echo "${ECHO_T}unsupported" >&6; } ;;+  *)+    CC="$CC $ac_cv_prog_cc_c89"+    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5+echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;+esac+++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu++++{ echo "$as_me:$LINENO: checking for mxDestroyArray in -lmx" >&5+echo $ECHO_N "checking for mxDestroyArray in -lmx... $ECHO_C" >&6; }+if test "${ac_cv_lib_mx_mxDestroyArray+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  ac_check_lib_save_LIBS=$LIBS+LIBS="-lmx  $LIBS"+cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++/* Override any GCC internal prototype to avoid an error.+   Use char because int might match the return type of a GCC+   builtin and then its argument prototype would still apply.  */+#ifdef __cplusplus+extern "C"+#endif+char mxDestroyArray ();+int+main ()+{+return mxDestroyArray ();+  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext conftest$ac_exeext+if { (ac_try="$ac_link"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_link") 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } && {+	 test -z "$ac_c_werror_flag" ||+	 test ! -s conftest.err+       } && test -s conftest$ac_exeext &&+       $as_test_x conftest$ac_exeext; then+  ac_cv_lib_mx_mxDestroyArray=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++	ac_cv_lib_mx_mxDestroyArray=no+fi++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \+      conftest$ac_exeext conftest.$ac_ext+LIBS=$ac_check_lib_save_LIBS+fi+{ echo "$as_me:$LINENO: result: $ac_cv_lib_mx_mxDestroyArray" >&5+echo "${ECHO_T}$ac_cv_lib_mx_mxDestroyArray" >&6; }+if test $ac_cv_lib_mx_mxDestroyArray = yes; then+  cat >>confdefs.h <<_ACEOF+#define HAVE_LIBMX 1+_ACEOF++  LIBS="-lmx $LIBS"++else+  { { echo "$as_me:$LINENO: error: Matlab array library not found" >&5+echo "$as_me: error: Matlab array library not found" >&2;}+   { (exit 1); exit 1; }; }+fi+++{ echo "$as_me:$LINENO: checking for engEvalString in -leng" >&5+echo $ECHO_N "checking for engEvalString in -leng... $ECHO_C" >&6; }+if test "${ac_cv_lib_eng_engEvalString+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  ac_check_lib_save_LIBS=$LIBS+LIBS="-leng  $LIBS"+cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++/* Override any GCC internal prototype to avoid an error.+   Use char because int might match the return type of a GCC+   builtin and then its argument prototype would still apply.  */+#ifdef __cplusplus+extern "C"+#endif+char engEvalString ();+int+main ()+{+return engEvalString ();+  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext conftest$ac_exeext+if { (ac_try="$ac_link"+case "(($ac_try" in+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+  *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+  (eval "$ac_link") 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } && {+	 test -z "$ac_c_werror_flag" ||+	 test ! -s conftest.err+       } && test -s conftest$ac_exeext &&+       $as_test_x conftest$ac_exeext; then+  ac_cv_lib_eng_engEvalString=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++	ac_cv_lib_eng_engEvalString=no+fi++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \+      conftest$ac_exeext conftest.$ac_ext+LIBS=$ac_check_lib_save_LIBS+fi+{ echo "$as_me:$LINENO: result: $ac_cv_lib_eng_engEvalString" >&5+echo "${ECHO_T}$ac_cv_lib_eng_engEvalString" >&6; }+if test $ac_cv_lib_eng_engEvalString = yes; then+  cat >>confdefs.h <<_ACEOF+#define HAVE_LIBENG 1+_ACEOF++  LIBS="-leng $LIBS"++else+  { { echo "$as_me:$LINENO: error: Matlab engine library not found" >&5+echo "$as_me: error: Matlab engine library not found" >&2;}+   { (exit 1); exit 1; }; }+fi++LDFLAGS="$save_ldflags"++if test "$use_runtime" == yes; then+  # Extract the first word of "mcc", so it can be a program name with args.+set dummy mcc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_path_MATLAB_MCC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  case $MATLAB_MCC in+  [\\/]* | ?:[\\/]*)+  ac_cv_path_MATLAB_MCC="$MATLAB_MCC" # Let the user override the test with a path.+  ;;+  *)+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+as_dummy="$MATLAB_DIR/bin:$PATH"+for as_dir in $as_dummy+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+    ac_cv_path_MATLAB_MCC="$as_dir/$ac_word$ac_exec_ext"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done+IFS=$as_save_IFS++  ;;+esac+fi+MATLAB_MCC=$ac_cv_path_MATLAB_MCC+if test -n "$MATLAB_MCC"; then+  { echo "$as_me:$LINENO: result: $MATLAB_MCC" >&5+echo "${ECHO_T}$MATLAB_MCC" >&6; }+else+  { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++      if test \! -x "$MATLAB_MCC" -a -z "$with_mcr"; then+  { { echo "$as_me:$LINENO: error: Matlab compiler not found" >&5+echo "$as_me: error: Matlab compiler not found" >&2;}+   { (exit 1); exit 1; }; }+fi++fi+++++++++++ac_config_files="$ac_config_files matlab.buildinfo Foreign/Matlab/Config.hs src/Makefile test/Makefile"++cat >confcache <<\_ACEOF+# This file is a shell script that caches the results of configure+# tests run on this system so they can be shared between configure+# scripts and configure runs, see configure's option --config-cache.+# It is not useful on other systems.  If it contains results you don't+# want to keep, you may remove or edit it.+#+# config.status only pays attention to the cache file if you give it+# the --recheck option to rerun configure.+#+# `ac_cv_env_foo' variables (set or unset) will be overridden when+# loading this file, other *unset* `ac_cv_foo' will be assigned the+# following values.++_ACEOF++# The following way of writing the cache mishandles newlines in values,+# but we know of no workaround that is simple, portable, and efficient.+# So, we kill variables containing newlines.+# Ultrix sh set writes to stderr and can't be redirected directly,+# and sets the high bit in the cache file unless we assign to the vars.+(+  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do+    eval ac_val=\$$ac_var+    case $ac_val in #(+    *${as_nl}*)+      case $ac_var in #(+      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5+echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;+      esac+      case $ac_var in #(+      _ | IFS | as_nl) ;; #(+      *) $as_unset $ac_var ;;+      esac ;;+    esac+  done++  (set) 2>&1 |+    case $as_nl`(ac_space=' '; set) 2>&1` in #(+    *${as_nl}ac_space=\ *)+      # `set' does not quote correctly, so add quotes (double-quote+      # substitution turns \\\\ into \\, and sed turns \\ into \).+      sed -n \+	"s/'/'\\\\''/g;+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"+      ;; #(+    *)+      # `set' quotes correctly as required by POSIX, so do not add quotes.+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"+      ;;+    esac |+    sort+) |+  sed '+     /^ac_cv_env_/b end+     t clear+     :clear+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/+     t end+     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/+     :end' >>confcache+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else+  if test -w "$cache_file"; then+    test "x$cache_file" != "x/dev/null" &&+      { echo "$as_me:$LINENO: updating cache $cache_file" >&5+echo "$as_me: updating cache $cache_file" >&6;}+    cat confcache >$cache_file+  else+    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5+echo "$as_me: not updating unwritable cache $cache_file" >&6;}+  fi+fi+rm -f confcache++test "x$prefix" = xNONE && prefix=$ac_default_prefix+# Let make expand exec_prefix.+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'++# Transform confdefs.h into DEFS.+# Protect against shell expansion while executing Makefile rules.+# Protect against Makefile macro expansion.+#+# If the first sed substitution is executed (which looks for macros that+# take arguments), then branch to the quote section.  Otherwise,+# look for a macro that doesn't take arguments.+ac_script='+t clear+:clear+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\)/-D\1=\2/g+t quote+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)/-D\1=\2/g+t quote+b any+:quote+s/[	 `~#$^&*(){}\\|;'\''"<>?]/\\&/g+s/\[/\\&/g+s/\]/\\&/g+s/\$/$$/g+H+:any+${+	g+	s/^\n//+	s/\n/ /g+	p+}+'+DEFS=`sed -n "$ac_script" confdefs.h`+++ac_libobjs=+ac_ltlibobjs=+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue+  # 1. Remove the extension, and $U if already installed.+  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'+  ac_i=`echo "$ac_i" | sed "$ac_script"`+  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR+  #    will be set to the directory where LIBOBJS objects are built.+  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"+  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'+done+LIBOBJS=$ac_libobjs++LTLIBOBJS=$ac_ltlibobjs++++: ${CONFIG_STATUS=./config.status}+ac_clean_files_save=$ac_clean_files+ac_clean_files="$ac_clean_files $CONFIG_STATUS"+{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5+echo "$as_me: creating $CONFIG_STATUS" >&6;}+cat >$CONFIG_STATUS <<_ACEOF+#! $SHELL+# Generated by $as_me.+# Run this file to recreate the current configuration.+# Compiler output produced by configure, useful for debugging+# configure, is in config.log if it exists.++debug=false+ac_cs_recheck=false+ac_cs_silent=false+SHELL=\${CONFIG_SHELL-$SHELL}+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+## --------------------- ##+## M4sh Initialization.  ##+## --------------------- ##++# Be 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=:+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+  # is contrary to our usage.  Disable this feature.+  alias -g '${1+"$@"}'='"$@"'+  setopt NO_GLOB_SUBST+else+  case `(set -o) 2>/dev/null` in+  *posix*) set -o posix ;;+esac++fi+++++# PATH needs CR+# Avoid depending upon Character Ranges.+as_cr_letters='abcdefghijklmnopqrstuvwxyz'+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'+as_cr_Letters=$as_cr_letters$as_cr_LETTERS+as_cr_digits='0123456789'+as_cr_alnum=$as_cr_Letters$as_cr_digits++# The user is always right.+if test "${PATH_SEPARATOR+set}" != set; then+  echo "#! /bin/sh" >conf$$.sh+  echo  "exit 0"   >>conf$$.sh+  chmod +x conf$$.sh+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then+    PATH_SEPARATOR=';'+  else+    PATH_SEPARATOR=:+  fi+  rm -f conf$$.sh+fi++# Support unset when possible.+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then+  as_unset=unset+else+  as_unset=false+fi+++# IFS+# We need space, tab and new line, in precisely that order.  Quoting is+# there to prevent editors from complaining about space-tab.+# (If _AS_PATH_WALK were called with IFS unset, it would disable word+# splitting by setting IFS to empty value.)+as_nl='+'+IFS=" ""	$as_nl"++# Find who we are.  Look in the path if we contain no directory separator.+case $0 in+  *[\\/]* ) as_myself=$0 ;;+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break+done+IFS=$as_save_IFS++     ;;+esac+# We did not find ourselves, most probably we were run as `sh COMMAND'+# in which case we are not to be found in the path.+if test "x$as_myself" = x; then+  as_myself=$0+fi+if test ! -f "$as_myself"; then+  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2+  { (exit 1); exit 1; }+fi++# Work around bugs in pre-3.0 UWIN ksh.+for as_var in ENV MAIL MAILPATH+do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+done+PS1='$ '+PS2='> '+PS4='+ '++# NLS nuisances.+for as_var in \+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \+  LC_TELEPHONE LC_TIME+do+  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then+    eval $as_var=C; export $as_var+  else+    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+  fi+done++# Required to use basename.+if expr a : '\(a\)' >/dev/null 2>&1 &&+   test "X`expr 00001 : '.*\(...\)'`" = X001; then+  as_expr=expr+else+  as_expr=false+fi++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then+  as_basename=basename+else+  as_basename=false+fi+++# Name of the executable.+as_me=`$as_basename -- "$0" ||+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \+	 X"$0" : 'X\(//\)$' \| \+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||+echo X/"$0" |+    sed '/^.*\/\([^/][^/]*\)\/*$/{+	    s//\1/+	    q+	  }+	  /^X\/\(\/\/\)$/{+	    s//\1/+	    q+	  }+	  /^X\/\(\/\).*/{+	    s//\1/+	    q+	  }+	  s/.*/./; q'`++# CDPATH.+$as_unset CDPATH++++  as_lineno_1=$LINENO+  as_lineno_2=$LINENO+  test "x$as_lineno_1" != "x$as_lineno_2" &&+  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {++  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO+  # uniformly replaced by the line number.  The first 'sed' inserts a+  # line-number line after each line using $LINENO; the second 'sed'+  # does the real work.  The second script uses 'N' to pair each+  # line-number line with the line containing $LINENO, and appends+  # trailing '-' during substitution so that $LINENO is not a special+  # case at line end.+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the+  # scripts with optimization help from Paolo Bonzini.  Blame Lee+  # E. McMahon (1931-1989) for sed's syntax.  :-)+  sed -n '+    p+    /[$]LINENO/=+  ' <$as_myself |+    sed '+      s/[$]LINENO.*/&-/+      t lineno+      b+      :lineno+      N+      :loop+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/+      t loop+      s/-\n.*//+    ' >$as_me.lineno &&+  chmod +x "$as_me.lineno" ||+    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2+   { (exit 1); exit 1; }; }++  # Don't try to exec as it changes $[0], causing all sort of problems+  # (the dirname of $[0] is not the place where we might find the+  # original and so on.  Autoconf is especially sensitive to this).+  . "./$as_me.lineno"+  # Exit status is that of the last command.+  exit+}+++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then+  as_dirname=dirname+else+  as_dirname=false+fi++ECHO_C= ECHO_N= ECHO_T=+case `echo -n x` in+-n*)+  case `echo 'x\c'` in+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.+  *)   ECHO_C='\c';;+  esac;;+*)+  ECHO_N='-n';;+esac++if expr a : '\(a\)' >/dev/null 2>&1 &&+   test "X`expr 00001 : '.*\(...\)'`" = X001; then+  as_expr=expr+else+  as_expr=false+fi++rm -f conf$$ conf$$.exe conf$$.file+if test -d conf$$.dir; then+  rm -f conf$$.dir/conf$$.file+else+  rm -f conf$$.dir+  mkdir conf$$.dir+fi+echo >conf$$.file+if ln -s conf$$.file conf$$ 2>/dev/null; then+  as_ln_s='ln -s'+  # ... but there are two gotchas:+  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.+  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.+  # In both cases, we have to default to `cp -p'.+  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||+    as_ln_s='cp -p'+elif ln conf$$.file conf$$ 2>/dev/null; then+  as_ln_s=ln+else+  as_ln_s='cp -p'+fi+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file+rmdir conf$$.dir 2>/dev/null++if mkdir -p . 2>/dev/null; then+  as_mkdir_p=:+else+  test -d ./-p && rmdir ./-p+  as_mkdir_p=false+fi++if test -x / >/dev/null 2>&1; then+  as_test_x='test -x'+else+  if ls -dL / >/dev/null 2>&1; then+    as_ls_L_option=L+  else+    as_ls_L_option=+  fi+  as_test_x='+    eval sh -c '\''+      if test -d "$1"; then+        test -d "$1/.";+      else+	case $1 in+        -*)set "./$1";;+	esac;+	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in+	???[sx]*):;;*)false;;esac;fi+    '\'' sh+  '+fi+as_executable_p=$as_test_x++# Sed expression to map a string onto a valid CPP name.+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"++# Sed expression to map a string onto a valid variable name.+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"+++exec 6>&1++# Save the log message, to keep $[0] and so on meaningful, and to+# report actual input values of CONFIG_FILES etc. instead of their+# values after options handling.+ac_log="+This file was extended by Haskell Matlab interface $as_me 0.1, which was+generated by GNU Autoconf 2.61.  Invocation command line was++  CONFIG_FILES    = $CONFIG_FILES+  CONFIG_HEADERS  = $CONFIG_HEADERS+  CONFIG_LINKS    = $CONFIG_LINKS+  CONFIG_COMMANDS = $CONFIG_COMMANDS+  $ $0 $@++on `(hostname || uname -n) 2>/dev/null | sed 1q`+"++_ACEOF++cat >>$CONFIG_STATUS <<_ACEOF+# Files that config.status was made for.+config_files="$ac_config_files"++_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+ac_cs_usage="\+\`$as_me' instantiates files from templates according to the+current configuration.++Usage: $0 [OPTIONS] [FILE]...++  -h, --help       print this help, then exit+  -V, --version    print version number and configuration settings, then exit+  -q, --quiet      do not print progress messages+  -d, --debug      don't remove temporary files+      --recheck    update $as_me by reconfiguring in the same conditions+  --file=FILE[:TEMPLATE]+		   instantiate the configuration file FILE++Configuration files:+$config_files++Report bugs to <bug-autoconf@gnu.org>."++_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+ac_cs_version="\\+Haskell Matlab interface config.status 0.1+configured by $0, generated by GNU Autoconf 2.61,+  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"++Copyright (C) 2006 Free Software Foundation, Inc.+This config.status script is free software; the Free Software Foundation+gives unlimited permission to copy, distribute and modify it."++ac_pwd='$ac_pwd'+srcdir='$srcdir'+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+# If no file are specified by the user, then we need to provide default+# value.  By we need to know if files were specified by the user.+ac_need_defaults=:+while test $# != 0+do+  case $1 in+  --*=*)+    ac_option=`expr "X$1" : 'X\([^=]*\)='`+    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`+    ac_shift=:+    ;;+  *)+    ac_option=$1+    ac_optarg=$2+    ac_shift=shift+    ;;+  esac++  case $ac_option in+  # Handling of the options.+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)+    ac_cs_recheck=: ;;+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )+    echo "$ac_cs_version"; exit ;;+  --debug | --debu | --deb | --de | --d | -d )+    debug=: ;;+  --file | --fil | --fi | --f )+    $ac_shift+    CONFIG_FILES="$CONFIG_FILES $ac_optarg"+    ac_need_defaults=false;;+  --he | --h |  --help | --hel | -h )+    echo "$ac_cs_usage"; exit ;;+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \+  | -silent | --silent | --silen | --sile | --sil | --si | --s)+    ac_cs_silent=: ;;++  # This is an error.+  -*) { echo "$as_me: error: unrecognized option: $1+Try \`$0 --help' for more information." >&2+   { (exit 1); exit 1; }; } ;;++  *) ac_config_targets="$ac_config_targets $1"+     ac_need_defaults=false ;;++  esac+  shift+done++ac_configure_extra_args=++if $ac_cs_silent; then+  exec 6>/dev/null+  ac_configure_extra_args="$ac_configure_extra_args --silent"+fi++_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+if \$ac_cs_recheck; then+  echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6+  CONFIG_SHELL=$SHELL+  export CONFIG_SHELL+  exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion+fi++_ACEOF+cat >>$CONFIG_STATUS <<\_ACEOF+exec 5>>config.log+{+  echo+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX+## Running $as_me. ##+_ASBOX+  echo "$ac_log"+} >&5++_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF++# Handling of arguments.+for ac_config_target in $ac_config_targets+do+  case $ac_config_target in+    "matlab.buildinfo") CONFIG_FILES="$CONFIG_FILES matlab.buildinfo" ;;+    "Foreign/Matlab/Config.hs") CONFIG_FILES="$CONFIG_FILES Foreign/Matlab/Config.hs" ;;+    "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;+    "test/Makefile") CONFIG_FILES="$CONFIG_FILES test/Makefile" ;;++  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5+echo "$as_me: error: invalid argument: $ac_config_target" >&2;}+   { (exit 1); exit 1; }; };;+  esac+done+++# If the user did not use the arguments to specify the items to instantiate,+# then the envvar interface is used.  Set only those that are not.+# We use the long form for the default assignment because of an extremely+# bizarre bug on SunOS 4.1.3.+if $ac_need_defaults; then+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files+fi++# Have a temporary directory for convenience.  Make it in the build tree+# simply because there is no reason against having it here, and in addition,+# creating and moving files from /tmp can sometimes cause problems.+# Hook for its removal unless debugging.+# Note that there is a small window in which the directory will not be cleaned:+# after its creation but before its name has been assigned to `$tmp'.+$debug ||+{+  tmp=+  trap 'exit_status=$?+  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status+' 0+  trap '{ (exit 1); exit 1; }' 1 2 13 15+}+# Create a (secure) tmp directory for tmp files.++{+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&+  test -n "$tmp" && test -d "$tmp"+}  ||+{+  tmp=./conf$$-$RANDOM+  (umask 077 && mkdir "$tmp")+} ||+{+   echo "$me: cannot create a temporary directory in ." >&2+   { (exit 1); exit 1; }+}++#+# Set up the sed scripts for CONFIG_FILES section.+#++# No need to generate the scripts if there are no CONFIG_FILES.+# This happens for instance when ./config.status config.h+if test -n "$CONFIG_FILES"; then++_ACEOF++++ac_delim='%!_!# '+for ac_last_try in false false false false false :; do+  cat >conf$$subs.sed <<_ACEOF+SHELL!$SHELL$ac_delim+PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim+PACKAGE_NAME!$PACKAGE_NAME$ac_delim+PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim+PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim+PACKAGE_STRING!$PACKAGE_STRING$ac_delim+PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim+exec_prefix!$exec_prefix$ac_delim+prefix!$prefix$ac_delim+program_transform_name!$program_transform_name$ac_delim+bindir!$bindir$ac_delim+sbindir!$sbindir$ac_delim+libexecdir!$libexecdir$ac_delim+datarootdir!$datarootdir$ac_delim+datadir!$datadir$ac_delim+sysconfdir!$sysconfdir$ac_delim+sharedstatedir!$sharedstatedir$ac_delim+localstatedir!$localstatedir$ac_delim+includedir!$includedir$ac_delim+oldincludedir!$oldincludedir$ac_delim+docdir!$docdir$ac_delim+infodir!$infodir$ac_delim+htmldir!$htmldir$ac_delim+dvidir!$dvidir$ac_delim+pdfdir!$pdfdir$ac_delim+psdir!$psdir$ac_delim+libdir!$libdir$ac_delim+localedir!$localedir$ac_delim+mandir!$mandir$ac_delim+DEFS!$DEFS$ac_delim+ECHO_C!$ECHO_C$ac_delim+ECHO_N!$ECHO_N$ac_delim+ECHO_T!$ECHO_T$ac_delim+LIBS!$LIBS$ac_delim+build_alias!$build_alias$ac_delim+host_alias!$host_alias$ac_delim+target_alias!$target_alias$ac_delim+MATLAB_BIN!$MATLAB_BIN$ac_delim+CC!$CC$ac_delim+CFLAGS!$CFLAGS$ac_delim+LDFLAGS!$LDFLAGS$ac_delim+CPPFLAGS!$CPPFLAGS$ac_delim+ac_ct_CC!$ac_ct_CC$ac_delim+EXEEXT!$EXEEXT$ac_delim+OBJEXT!$OBJEXT$ac_delim+MATLAB_MCC!$MATLAB_MCC$ac_delim+MATLAB_DIR!$MATLAB_DIR$ac_delim+MATLAB_ARCH!$MATLAB_ARCH$ac_delim+MCCFLAGS!$MCCFLAGS$ac_delim+MATLAB_LIB_PATH!$MATLAB_LIB_PATH$ac_delim+MATLAB_LIB_DIR!$MATLAB_LIB_DIR$ac_delim+LIBOBJS!$LIBOBJS$ac_delim+LTLIBOBJS!$LTLIBOBJS$ac_delim+_ACEOF++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 53; then+    break+  elif $ac_last_try; then+    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5+echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}+   { (exit 1); exit 1; }; }+  else+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "+  fi+done++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`+if test -n "$ac_eof"; then+  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`+  ac_eof=`expr $ac_eof + 1`+fi++cat >>$CONFIG_STATUS <<_ACEOF+cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end+_ACEOF+sed '+s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g+s/^/s,@/; s/!/@,|#_!!_#|/+:n+t n+s/'"$ac_delim"'$/,g/; t+s/$/\\/; p+N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n+' >>$CONFIG_STATUS <conf$$subs.sed+rm -f conf$$subs.sed+cat >>$CONFIG_STATUS <<_ACEOF+:end+s/|#_!!_#|//g+CEOF$ac_eof+_ACEOF+++# VPATH may cause trouble with some makes, so we remove $(srcdir),+# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and+# trailing colons and then remove the whole line if VPATH becomes empty+# (actually we leave an empty line to preserve line numbers).+if test "x$srcdir" = x.; then+  ac_vpsub='/^[	 ]*VPATH[	 ]*=/{+s/:*\$(srcdir):*/:/+s/:*\${srcdir}:*/:/+s/:*@srcdir@:*/:/+s/^\([^=]*=[	 ]*\):*/\1/+s/:*$//+s/^[^=]*=[	 ]*$//+}'+fi++cat >>$CONFIG_STATUS <<\_ACEOF+fi # test -n "$CONFIG_FILES"+++for ac_tag in  :F $CONFIG_FILES+do+  case $ac_tag in+  :[FHLC]) ac_mode=$ac_tag; continue;;+  esac+  case $ac_mode$ac_tag in+  :[FHL]*:*);;+  :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5+echo "$as_me: error: Invalid tag $ac_tag." >&2;}+   { (exit 1); exit 1; }; };;+  :[FH]-) ac_tag=-:-;;+  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;+  esac+  ac_save_IFS=$IFS+  IFS=:+  set x $ac_tag+  IFS=$ac_save_IFS+  shift+  ac_file=$1+  shift++  case $ac_mode in+  :L) ac_source=$1;;+  :[FH])+    ac_file_inputs=+    for ac_f+    do+      case $ac_f in+      -) ac_f="$tmp/stdin";;+      *) # Look for the file first in the build tree, then in the source tree+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,+	 # because $ac_f cannot contain `:'.+	 test -f "$ac_f" ||+	   case $ac_f in+	   [\\/$]*) false;;+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;+	   esac ||+	   { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5+echo "$as_me: error: cannot find input file: $ac_f" >&2;}+   { (exit 1); exit 1; }; };;+      esac+      ac_file_inputs="$ac_file_inputs $ac_f"+    done++    # Let's still pretend it is `configure' which instantiates (i.e., don't+    # use $as_me), people would be surprised to read:+    #    /* config.h.  Generated by config.status.  */+    configure_input="Generated from "`IFS=:+	  echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."+    if test x"$ac_file" != x-; then+      configure_input="$ac_file.  $configure_input"+      { echo "$as_me:$LINENO: creating $ac_file" >&5+echo "$as_me: creating $ac_file" >&6;}+    fi++    case $ac_tag in+    *:-:* | *:-) cat >"$tmp/stdin";;+    esac+    ;;+  esac++  ac_dir=`$as_dirname -- "$ac_file" ||+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+	 X"$ac_file" : 'X\(//\)[^/]' \| \+	 X"$ac_file" : 'X\(//\)$' \| \+	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||+echo X"$ac_file" |+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{+	    s//\1/+	    q+	  }+	  /^X\(\/\/\)[^/].*/{+	    s//\1/+	    q+	  }+	  /^X\(\/\/\)$/{+	    s//\1/+	    q+	  }+	  /^X\(\/\).*/{+	    s//\1/+	    q+	  }+	  s/.*/./; q'`+  { as_dir="$ac_dir"+  case $as_dir in #(+  -*) as_dir=./$as_dir;;+  esac+  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {+    as_dirs=+    while :; do+      case $as_dir in #(+      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(+      *) as_qdir=$as_dir;;+      esac+      as_dirs="'$as_qdir' $as_dirs"+      as_dir=`$as_dirname -- "$as_dir" ||+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+	 X"$as_dir" : 'X\(//\)[^/]' \| \+	 X"$as_dir" : 'X\(//\)$' \| \+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||+echo X"$as_dir" |+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{+	    s//\1/+	    q+	  }+	  /^X\(\/\/\)[^/].*/{+	    s//\1/+	    q+	  }+	  /^X\(\/\/\)$/{+	    s//\1/+	    q+	  }+	  /^X\(\/\).*/{+	    s//\1/+	    q+	  }+	  s/.*/./; q'`+      test -d "$as_dir" && break+    done+    test -z "$as_dirs" || eval "mkdir $as_dirs"+  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5+echo "$as_me: error: cannot create directory $as_dir" >&2;}+   { (exit 1); exit 1; }; }; }+  ac_builddir=.++case "$ac_dir" in+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;+*)+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`+  # A ".." for each directory in $ac_dir_suffix.+  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`+  case $ac_top_builddir_sub in+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;+  esac ;;+esac+ac_abs_top_builddir=$ac_pwd+ac_abs_builddir=$ac_pwd$ac_dir_suffix+# for backward compatibility:+ac_top_builddir=$ac_top_build_prefix++case $srcdir in+  .)  # We are building in place.+    ac_srcdir=.+    ac_top_srcdir=$ac_top_builddir_sub+    ac_abs_top_srcdir=$ac_pwd ;;+  [\\/]* | ?:[\\/]* )  # Absolute name.+    ac_srcdir=$srcdir$ac_dir_suffix;+    ac_top_srcdir=$srcdir+    ac_abs_top_srcdir=$srcdir ;;+  *) # Relative name.+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix+    ac_top_srcdir=$ac_top_build_prefix$srcdir+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;+esac+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix+++  case $ac_mode in+  :F)+  #+  # CONFIG_FILE+  #++_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+# If the template does not know about datarootdir, expand it.+# FIXME: This hack should be removed a few years after 2.60.+ac_datarootdir_hack=; ac_datarootdir_seen=++case `sed -n '/datarootdir/ {+  p+  q+}+/@datadir@/p+/@docdir@/p+/@infodir@/p+/@localedir@/p+/@mandir@/p+' $ac_file_inputs` in+*datarootdir*) ac_datarootdir_seen=yes;;+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)+  { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5+echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}+_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+  ac_datarootdir_hack='+  s&@datadir@&$datadir&g+  s&@docdir@&$docdir&g+  s&@infodir@&$infodir&g+  s&@localedir@&$localedir&g+  s&@mandir@&$mandir&g+    s&\\\${datarootdir}&$datarootdir&g' ;;+esac+_ACEOF++# Neutralize VPATH when `$srcdir' = `.'.+# Shell code in configure.ac might set extrasub.+# FIXME: do we really want to maintain this feature?+cat >>$CONFIG_STATUS <<_ACEOF+  sed "$ac_vpsub+$extrasub+_ACEOF+cat >>$CONFIG_STATUS <<\_ACEOF+:t+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b+s&@configure_input@&$configure_input&;t t+s&@top_builddir@&$ac_top_builddir_sub&;t t+s&@srcdir@&$ac_srcdir&;t t+s&@abs_srcdir@&$ac_abs_srcdir&;t t+s&@top_srcdir@&$ac_top_srcdir&;t t+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t+s&@builddir@&$ac_builddir&;t t+s&@abs_builddir@&$ac_abs_builddir&;t t+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t+$ac_datarootdir_hack+" $ac_file_inputs | sed -f "$tmp/subs-1.sed" >$tmp/out++test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&+  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&+  { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'+which seems to be undefined.  Please make sure it is defined." >&5+echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'+which seems to be undefined.  Please make sure it is defined." >&2;}++  rm -f "$tmp/stdin"+  case $ac_file in+  -) cat "$tmp/out"; rm -f "$tmp/out";;+  *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;;+  esac+ ;;++++  esac++done # for ac_tag+++{ (exit 0); exit 0; }+_ACEOF+chmod +x $CONFIG_STATUS+ac_clean_files=$ac_clean_files_save+++# configure is writing to config.log, and then calls config.status.+# config.status does its own redirection, appending to config.log.+# Unfortunately, on DOS this fails, as config.log is still kept open+# by configure, so config.status won't be able to write to it; its+# output is simply discarded.  So we exec the FD to /dev/null,+# effectively closing config.log, so it can be properly (re)opened and+# appended to by config.status.  When coming back to configure, we+# need to make the FD available again.+if test "$no_create" != yes; then+  ac_cs_success=:+  ac_config_status_args=+  test "$silent" = yes &&+    ac_config_status_args="$ac_config_status_args --quiet"+  exec 5>/dev/null+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false+  exec 5>>config.log+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which+  # would make configure fail if this is the last instruction.+  $ac_cs_success || { (exit 1); exit 1; }+fi+

@@ -0,0 +1,3 @@+include-dirs: @srcdir@/src @MATLAB_DIR@/extern/include+extra-lib-dirs: @MATLAB_LIB_PATH@+ld-options: "-Wl,-rpath,@MATLAB_LIB_DIR@" "-Wl,--disable-new-dtags"

@@ -0,0 +1,43 @@+Name:		matlab+Version:	0.1+Cabal-Version:  >= 1.6+Author:		Dylan Simon+Maintainer:     dylan@dylex.net+License:        BSD3+Synopsis:	Matlab bindings and interface+Description:	This package aims to provide a comprehensive interface to the MathWorks MATLAB(R) libraries and native data structures, including complete matrix access, MAT-format files, linking and execution of runtime libraries and engine.  Requires MATLAB for full functionality or an installed Matlab Component Runtime (MCR).  This has been tested with MATLAB 7.5-7.7 and might work with others.+Category:	Foreign,Math+build-type:	Custom+tested-with:    GHC == 6.8.3+extra-source-files: configure matlab.buildinfo.in Foreign/Matlab/Config.hs.in+		src/Makefile.in src/hsmatlab.m src/hsmatlab.c src/hsc_sym.h+		test/Makefile.in test/engine.hs test/runtime.hs test/generic.hs test/mtest.m test/hsmli.hs+extra-tmp-files: matlab.buildinfo Foreign/Matlab/Config.hs+		src/Makefile++Flag Engine+    Description:	Enable Matlab engine (spawned eng process) support+Flag Runtime+    Description:	Enable Matlab runtime (linked library) support+Flag MCR+    Description:	Use installed Matlab Component Runtime instead of full Matlab+    default:		False++Library+    Build-depends:	base < 4, unix, array, filepath, Cabal+    Exposed-modules:	Foreign.Matlab, Foreign.Matlab.Types, Foreign.Matlab.Array, Foreign.Matlab.Array.Auto, Foreign.Matlab.Array.MArray, Foreign.Matlab.Array.IMX, Foreign.Matlab.Array.Able, Foreign.Matlab.MAT+    if flag(engine)+        Exposed-modules: Foreign.Matlab.Engine+    if flag(runtime)+        Exposed-modules: Foreign.Matlab.Runtime, Foreign.Matlab.Runtime.Generic+    Other-modules:	Foreign.Matlab.Config, Foreign.Matlab.Util, Foreign.Matlab.Internal+    Extensions:         ForeignFunctionInterface, TypeSynonymInstances, MultiParamTypeClasses, FunctionalDependencies, EmptyDataDecls, ScopedTypeVariables, LiberalTypeSynonyms, DeriveDataTypeable, FlexibleInstances, UndecidableInstances+    ghc-options:        -Wall -fno-warn-name-shadowing+    extra-libraries:    mx+    if flag(engine)+        extra-libraries: eng+    if flag(mcr)+        build-tools:	mcr+    else+        build-tools:	matlab+    extra-lib-dirs:	src

@@ -0,0 +1,19 @@+MCC=@MATLAB_MCC@+MCCFLAGS=@MCCFLAGS@++libhsmatlab.so: hsmatlab.m hsmatlab.c+	rm -f $@ $@.post+	# just create the wrapper+	$(MCC) $(MCCFLAGS) -W lib:$(basename $@) -c hsmatlab.m+	# matlab 7.6 sticks the ctf at the end of the library, but has a bug when not creating libraries that it tries anyway, so we check that here+	-[ -f $@ ] && mv $@ $@.post+	# stick our own call into the wrapper+	cat hsmatlab.c >> $(basename $@).c+	# build the library+	$(MCC) $(MCCFLAGS) -W none -T link:lib $(basename $@).c+	# 7.6: do what mcc tried to do before+	-[ -f $@.post ] && cat $(basename $@).ctf >> $@ ++clean:+	rm -rf libhsmatlab_mcr+	rm -f libhsmatlab* mccExcludedFiles.log readme.txt

@@ -0,0 +1,2 @@+#define hsc_SYM2(X) hsc_const_str(#X)+#define hsc_SYM(X) hsc_SYM2(X)

@@ -0,0 +1,6 @@+/* a thin wrapper to add to the library to allow for arbitrary function calls */+LIB_libhsmatlab_C_API +bool MW_CALL_CONV mlHsFeval(const char *fun, int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])+{+  return mclFeval(_mcr_inst, fun, nlhs, plhs, nrhs, prhs);+}

@@ -0,0 +1,1 @@+function hsmatlab

@@ -0,0 +1,22 @@+MCC=@MATLAB_MCC@+MCCFLAGS=@MCCFLAGS@++TESTS=engine runtime generic+default: $(TESTS)+	@echo "All tests should have produced:"+	@echo "  ready"+	@echo "  MXClassDouble"+	@echo "  -1.0"+	@for t in $^ ; do echo Running $$t... ; ./$$t ; done++%: %.hs+	ghc -I.. --make $@++lib%.so: %.m+	$(MCC) $(MCCFLAGS) -W lib:$(basename $@) -T link:lib $^++runtime: libmtest.so++clean:+	rm -rf libmtest_mcr+	rm -f *.o *.hi $(TESTS) libmtest* mccExcludedFiles.log readme.txt

@@ -0,0 +1,12 @@+import Foreign.Matlab+import Foreign.Matlab.Engine++main = do+  eng <- newEngine Nothing+  putStrLn "ready"+  x <- createMXScalar (pi :: MDouble)+  [y] <- engineEvalFun eng "cos" [EvalArray x] 1+  mxArrayClass y >>= print+  Just y <- castMXArray y+  y <- mxScalarGet y+  print (y :: MDouble)

@@ -0,0 +1,13 @@+import Foreign.Matlab+import Foreign.Matlab.Runtime.Generic++main = do+  ml <- openMLGeneric ["-nojvm", "-nojit"]+  putStrLn "ready"+  x <- createMXScalar (pi :: MDouble)+  [y] <- mlGenericFun ml "cos" [anyMXArray x] 1+  mxArrayClass y >>= print+  Just y <- castMXArray y+  y <- mxScalarGet y+  print (y :: MDouble)+  closeMLGeneric ml

@@ -0,0 +1,15 @@+import Control.Monad+import Foreign.Matlab+import Foreign.Matlab.Runtime.Generic++loop ml = do+  i <- getLine+  when (i /= "") $ do+    mlGenericEval ml i 0+    loop ml++main = do+  ml <- openMLGeneric ["-nojvm", "-nojit"]+  putStrLn "ready. enter matlab expression or blank line to exit."+  loop ml+  closeMLGeneric ml

@@ -0,0 +1,2 @@+function y = mtest(x)+y = cos(x);

@@ -0,0 +1,13 @@+import Foreign.Matlab+import Foreign.Matlab.Runtime++main = do+  ml <- openMLibrary "./mtest" ["-nojvm", "-nojit"]+  putStrLn "ready"+  x <- createMXScalar (pi :: MDouble)+  [y] <- mLibraryCall ml "mtest" [anyMXArray x] 1+  mxArrayClass y >>= print+  Just y <- castMXArray y+  y <- mxScalarGet y+  print (y :: MDouble)+  closeMLibrary ml