The problem isn't using allocatable variables ... MATLAB mex functions can handle that just fine. The problem is that you are using two different types of floating point variables, single (aka real) and double (aka real*8). You allocate the variable as real (4-bytes per element) but then copy it as if it is real*8 (8 bytes per element), so you access invalid memory and get the seg fault. The fix is to be consistent with your floating point types ... use either real or real*8. If you use real then you would need to use the mxCopyPtrToReal4 and mxCopyReal4ToPtr functions. If you use real*8 then you can use the mxCopyPtrToReal8 and mxCopyReal8ToPtr functions. Also for readability you should be using mxGetSingles for real variables, although this doesn't really make a difference in Fortran since the address is just returned in an integer variable. You could also be generic and just use mxGetData for this, which will work in both the R2017b and R2018a API memory models.
I would also strongly advise putting in argument checking code in mex functions to avoid unexpected arguments causing erroneous results or seg faults.
As an aside, what you are doing is fine for small variables where the deep data copies don't hurt performance much. But if you are using very large variables in your actual problem, you would want to avoid the deep data copies if at all possible. That would mean doing something like using the %VAL(etc) construct in your code to pass pointers by value to implicit interface subroutines. E.g., you could do something like this (Caveat ... I don't have a Fortran compiler so this is all untested):
#include "fintrf.h"
subroutine mexFunction(nlhs, plhs, nrhs, prhs)
implicit none
mwPointer :: plhs(*), prhs(*)
integer :: nlhs, nrhs
! using external makes it clear to the reader that these are functions
mwPointer, external :: mxGetDoubles
mwPointer, external :: mxCreateDoubleMatrix
mwPointer, external :: mxGetM, mxGetN
integer*4, external :: mxIsDouble, mxIsComplex, mxIsSparse
mwPointer :: A_ptr, B_ptr
mwSize :: m, n ! changed to mwSize to match mxCreateDoubleMatrix signature exactly
integer*4 :: ComplexFlag = 0 ! added explicit type to match mxCreateDoubleMatrix signature
! adding argument checks
if( nlhs > 1 ) then
call mexErrMsgTxt('Too many outputs')
endif
if( nrhs != 1 ) then
call mexErrMsgTxt('Need one full real double input')
endif
if( mxIsDouble(prhs(1))==0 .or. mxIsComplex(prhs(1))==1 .or. mxIsSparse(prhs(1))==1 ) then
call mexErrMsgTxt('Need one full real double input')
endif
m = mxGetM(prhs(1)) ! mwSize = mwPointer
n = mxGetN(prhs(1)) ! mwSize = mwPointer
! RHS: input args
A_ptr = mxGetDoubles(prhs(1))
! LHS: return vals
plhs(1) = mxCreateDoubleMatrix(m, n, ComplexFlag) ! using explicit typed variable for argument
if( m*n /= 0 ) then ! check for empty variable
B_ptr = mxGetDoubles(plhs(1))
call copyab(%VAL(A_ptr), %VAL(B_ptr), m, n) ! pass addresses by value
endif
end subroutine mexFunction
subroutine copyab(A, B, m, n)
implicit none
mwSize :: m, n
real*8 :: A(m,n), B(m,n) ! changed to real*8 to match doubles in calling routine exactly
B = A
end subroutine copyab
Note that you should never pass literal integers to Fortran API functions, since in many cases you can't guarantee what the size of integer the compiler will use (depends on mex and compiler settings). Always use variables that are explicitly typed according to the API interface documentation to avoid problems.
