MATLAB: MxCreateString usage when calling matlab

mex

I try to call a function from mex in matlab and for this reason I made a mxArray because the function has two inputs namely a first one which is text and the second one which is a number.

My function works when I have static text, but not when I want to use the input to the mex-function. In the latter case I only get the first letter and not all 49 characters so I assume there is a problem with the pointers but I seriously cannot figure out were the problem lies

working code:

mxArray *callInput[2];
double inputNumber;
....
callInput[0] = mxCreateString("StringBeingPassed");
callInput[1] = mxCreateDoubleScalar(inputNumber);
mexCallMATLAB(0,NULL,2, callInput,"functionName");

NOT working anymore (only first letter being passed to function):

mxArray *callInput[2], *stringMX;
char *string_pr;
char string[49];
double inputNumber;
  ....
stringMX = mxGetField(prhs[0],0,"string");
string_pr = mxGetData(stringMX);
for (ii=0;ii<49;ii++){
    *(yearString+ii) = *(yearString_pr+ii);
}
callInput[0] = mxCreateString(string);
callInput[1] = mxCreateDoubleScalar(inputNumber);
mexCallMATLAB(0,NULL,2, callInput,"functionName");

Best Answer

MATLAB strings are stored internally as 2 bytes per character, not 1 byte per character. For regular ASCII text, that means that one of those bytes will be 0 (i.e., a null character). So in your for-loop you are actually only copying half the string, and every other byte you are copying is a null character. So the mxCreateString function only sees the first character (the 2nd being the first null character). Hence only 1 character gets copied in the mxArray you are creating. Some options:

1) Skip all the character-by-character copying and just use what you want, since it is already in mxArray form (recommended):

callInput[0] = stringMX;

2) Use an official API function to do this. E.g. (maybe you need the text as a C-string for some reason),

character *string;
string = mxArrayToString(stringMX);
callInput[0] = mxCreateString(string);
mxFree(string);

You can do the character-by-character copying manually, but you would have to copy every-other-character of the input and then tack on the null character yourself, ensuring that you don't run over the end of the input string during the copy (i.e., don't hard code a 49).

Related Solutions

MATLAB: How do you copy MATLAB strings to Fortran character variables

Although it is not at all obvious from reading the doc, the mxCopyPtrToCharacter routine is intended to work only with C-style null-terminated strings that come from mat directories, not MATLAB character strings. Uh ... what??? I thought we were talking about Fortran, not C!!! Yes, we are, and yes, you read that correctly. Although these are Fortran API routines, the input string data they point to are assumed to be built using lower level C-style null-terminated strings. These Fortran API functions are pretty much useful only for reading the mat directory stuff (pointer to an array of char pointers) into Fortran variables. They are useless for converting a MATLAB char string into a Fortran character string.

The only clue you have to this fact is by carefully examining the example code in the supplied matdemo2.F file and having some knowledge of the similar functions in the C API. The matgetdir(mp, temp) call gets a pointer to an array of C-style (char *) types assumed to be null-terminated. Then the mxCopyPtrToPtrArray(dir, adir, ndir) call copies these C-style null-terminated string pointers into a Fortran mwPointer array (but the underlying strings these addresses point to are still C-style null terminated strings). Then the mxCopyPtrToCharacter(adir(i), names(i), M) call finally copies the C-style null-terminated string data itself into the Fortran character string variable.

The reason your code is only copying one character is because MATLAB char strings are 2-bytes per character. For typical ASCII characters, one of those bytes is null (0). When you pass the address of this to a routine expecting a C-style null-terminated string as input (1-byte per char), the routine sees that 0 in the 2nd byte and thinks it is the end of the C-style null-terminated string after copying only the first byte. Not what you wanted or expected.

OK, a lot of verbiage above mainly for background and to give more detail to the usage of the Fortran API functions. This answers why your code doesn't work, but doesn't solve your problem.

To get a MATLAB char string variable copied into a Fortran character string variable, you need to write custom code to do it. There are no API functions available for this unfortunately. This can be accomplished by recognizing that MATLAB char data is 2-bytes per character. Using that knowledge, one can type-pun the address of the MATLAB char data into an integer*2 array, then use those integer*2 values as ASCII codes to convert them into single characters in Fortran. The good news for you is I have already done that. The routine is posted below.

CAVEAT: I wrote this quickly off the top of my head ... it has not been compiled or tested. If you find bugs let me know.

!-----------------------------------------------------------------
!
! Copies MATLAB character string to Fortran character string
!
! Input:   mx  -->  Address of mxArray containing char string
!
! Outputs: s   -->  Fortran character string (blank padded at end)
!
! Programmer:  James Tursa
!
!-----------------------------------------------------------------
!
      subroutine mxArrayToCharacter( mx, s )
      implicit none
! ARG
      mwPointer mx
      character*(*) s
! FUN
      mwPointer, external :: mxGetData
      integer*4, external :: mxIsChar
      mwPointer, external :: mxGetNumberOfElements
! LOC
      mwPointer pr
      mwPointer n
!-----
!\
! Check for NULL input
!/
      if( mx == 0 ) then
          s = ' '
          return
      endif
!\
! Check for char string input
!/
      if( mxIsChar(mx) == 0 ) then
          s = ' '
          return
      endif
!\
! Get char data pointer and number of characters
!/
      pr = mxGetData(mx)
      n  = mxGetNumberOfElements(mx)
!\
! Call utility routine to treat MATLAB char data as integer*2
!/
      call mxCopyI2toCharacter( %VAL(pr), n, s )
        end subroutine
  !
  !-----------------------------------------------------------------
  !
        subroutine mxCopyI2toCharacter( I2, n, s )
        implicit none
  !-ARG
        mwPointer n
        integer*2 I2(n)
        character*(*) s
  !-LOC
        mwPointer i, m
  !-----
  !\
  ! Copy 1 character at a time, using the 2-byte MATLAB char value as
  ! an integer value containing the ASCII character code. If there are
  ! not enough characters to fill s, blank pad the end.
  !/
        m = len(s)
        do i=1,min(m,n)
            s(i:i) = achar(I2(i))
        enddo
        if( n < m ) then
            s(n+1:) = ' '
        endif
        return
        end subroutine

MATLAB: How to call mxArray with varargin in C; mxCreateCellMatrix and mxSetCell

Oyvind- it isn't clear how you are executing the above code. Is it part of a C program that you are running? Where is the function that you are providing the variable number of inputs to? How does wmlfNor relate to this function, as you seem to be just passing in strings here?

If I take the body of your above code and paste it into a MEX function (commenting out the returnval stuff and the call to the mlfNor function), the build/compile works fine, but crashes as soon as I call the MEX function. (Note that I created dummy strings in place of your input parameters.)

What seems to be happening is that the code is trying to destroy/free the same allocated memory twice at

 mxDestroyArray(pfinp);
 mxDestroyArray(pfana);
 mxDestroyArray(pfcsv);
 mxDestroyArray(pvarargin);

We destroy the mxArrays that correspond to the three strings created with mxCreateString, and then try to destroy the cell array, pvarargin, which tries to destroy/free all cells...which includes the three (string) mxArrays which we just destroyed. If you comment out these three lines and just do

 //mxDestroyArray(pfinp);
 //mxDestroyArray(pfana);
 //mxDestroyArray(pfcsv);
 mxDestroyArray(pvarargin);

it works fine: there is no crash when running the MEX function. To see the effects of this more clearly, do the following: free/destroy the memory to the three string arrays, and then set each of the three cells in pvarargin to NULL, then destroy the cell array

 mxDestroyArray(pfinp);
 mxDestroyArray(pfana);
 mxDestroyArray(pfcsv);
 mxSetCell(pvarargin,0,NULL);
 mxSetCell(pvarargin,1,NULL);
 mxSetCell(pvarargin,2,NULL);
 mxDestroyArray(pvarargin);

Again, the function can be built/compiled without any problems, and the MEX function can be run.

Try using one of the above two options in your code, and see if that prevents the crash.

Best Answer

Related Solutions

MATLAB: How do you copy MATLAB strings to Fortran character variables

MATLAB: How to call mxArray with varargin in C; mxCreateCellMatrix and mxSetCell

Related Question