mexlib.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
vraiptrst	stkptr (long int ptr_lstk)
int *	Header (const mxArray *ptr)
mxArray *	header2ptr (int *header)
int *	listentry (int *header, int i)
int	theMLIST (int *header)
int *	RawHeader (const mxArray *ptr)
int	Is1x1 (const mxArray *ptr)
mxArray *	mxCreateData (int m)
void	mxAssert (int expr, char *error_message)
void *	mxRealloc (void *ptr, size_t nsize)
void	mexMakeMemoryPersistent (void *ptr)
int	IsstOrce (mxArray *ptr)
void	numberandsize (const mxArray *ptr, int *number, int *size)
bool	mexIsGlobal (const mxArray *ptr)
mxArray *	UnrefStruct (mxArray *ptr)
mxArray *	mxCreateLogicalMatrix (int m, int n)
mxArray *	mxCreateLogicalScalar (mxLOGICAL *value)
bool	mxIsLogicalScalarTrue (mxArray *pa)
bool	mxIsLogicalScalar (mxArray *pa)
const char *	mexFunctionName (void)
int	mexPutArray (mxArray *array_ptr, char *workspace)
int	mexPutVariable (const char *workspace, char *var_name, mxArray *array_ptr)
const char *	mxGetClassName (const mxArray *ptr)
mxArray *C2F()	mxcreatedoublematrix (int *m, int *n, int *it)
int C2F()	mxcopycomplex16toptr (double *y, mxArray *ptr, mxArray *pti, integer *n)
int C2F()	mxcopyptrtocomplex16 (mxArray *ptr, mxArray *pti, double *y, integer *n)

---

Function Documentation

int* Header

(

const mxArray *

ptr

)

TODO : comment

Parameters:

ptr

Returns:

Definition at line 104 of file mexlib.c.

References stk, and stkptr().

{
  /* Retuns an integer pointer to the header of a mxArray */
  int *header = (int *) stkptr((long int)ptr);
  if (header[0] < 0) header = (int *) stk(header[1]);
  return header;
}

Here is the call graph for this function:

mxArray* header2ptr

(

int *

header

)

TODO : comment

Parameters:

header

Returns:

Definition at line 113 of file mexlib.c.

References C2F, lstk, and stkptr().

{
  mxArray ptr;
  ptr=(mxArray) ((double *)header-(double *)stkptr(C2F(vstk).lstk[0])+C2F(vstk).lstk[0]) ;
  return (mxArray *) ptr;
}

Here is the call graph for this function:

int Is1x1

(

const mxArray *

ptr

)

TODO : comment

Parameters:

ptr

Returns:

Definition at line 401 of file mexlib.c.

References listentry(), and RawHeader().

{
  int proddims,k;
  int *header = RawHeader(ptr);
  int *headerdims = listentry(header,2);
  proddims=1;
  for (k=0; k<headerdims[1]*headerdims[2]; k++) {
    proddims=proddims*headerdims[4+k];
  }
  return (int) proddims==1;
}

Here is the call graph for this function:

int IsstOrce

(

mxArray *

ptr

)

TODO : comment

Parameters:

ptr

Returns:

Definition at line 1511 of file mexlib.c.

References Header(), l, listentry(), MLIST, and STRINGMATRIX.

{
  int *header1; int l; int nfplus2;
  int *header = Header(ptr);
  if (header[0]==MLIST) {
    header1 = (int *) listentry(header,1);
    nfplus2 = header1[1]*header1[2];
    l = 5 + nfplus2;
    if (header1[0]==STRINGMATRIX)
        if (header1[l]==12 && header1[l+1]==14) return 1;  /*  "ce"  */
        if (header1[l]==28 && header1[l+1]==29) return 1;  /*  "st"  */
    else return 0;
      }
  else return 0;
}

Here is the call graph for this function:

int* listentry	(	int *	header,
		int	i
	)

TODO : comment

Parameters:

	header
	i

Returns:

Definition at line 120 of file mexlib.c.

{
  /*Usage int *header = header(array_ptr)   
   *      int *headersub = listentry(header, k)
   *   then headersub[0] ... is the header of the kth object in the
   *   list array_ptr  */
  int n, *ptr; 
  n = header[1]; 
  if (i <= n) {
    if ( n%2 == 0 ) n++;
    /* n = n if n odd, n=n+1 if n even (=> n is odd and ptr even !) */
    ptr = (int *) header + 3 + n + 2*( header[2 + (i - 1) ] -1);
  return ptr;
  } else {
    return NULL;
  }
}

const char* mexFunctionName

(

void

)

generic mex interface

Definition at line 2121 of file mexlib.c.

References the_current_mex_name.

{ return the_current_mex_name;}

bool mexIsGlobal

(

const mxArray *

ptr

)

TODO : comment

Parameters:

ptr

Returns:

Definition at line 1669 of file mexlib.c.

References arr2numcst(), Header(), Infstk, and RawHeader().

{
  int pointed;
  int ret_val;
  int *header;int *rheader;
  header=(int *) Header(ptr);
  rheader=(int *) RawHeader(ptr);
  pointed = arr2numcst(ptr);
  /*  A FINIR si interface par reference OK  
      printf("POINTED %i Infstk(pointed) %i\n", pointed, *Infstk(pointed));
      printf("header[2] %i Infstk(pointed) %i\n", header[2], *Infstk(header[2])); */
  pointed=header[2];
  if (*Infstk(pointed) == 2) 
   ret_val = 1;
  else
   ret_val = 0;
  return ret_val;
}

Here is the call graph for this function:

void mexMakeMemoryPersistent

(

void *

ptr

)

TODO : comment

Parameters:

ptr

Definition at line 1419 of file mexlib.c.

References calloc_table, and rec_size.

                                        {
  int i;
  for ( i = 0 ; i < rec_size ; i++) {
    if (calloc_table[i].adr == ptr)
      {
        if  (calloc_table[i].keep == 1 ) 
          {
            calloc_table[i].keep = 2;
          }
      }
  }
}

int mexPutArray	(	mxArray *	array_ptr,
		char *	workspace
	)

TODO : comment

Parameters:

	array_ptr
	workspace

Returns:

Definition at line 2293 of file mexlib.c.

References mexPrintf().

{
  /* TO BE DONE obsolete ?  */
  mexPrintf( "Function mexPutArray is obsolete, use mexPutVariable! \n");
  return 1;
}

Here is the call graph for this function:

int mexPutVariable	(	const char *	workspace,
		char *	var_name,
		mxArray *	array_ptr
	)

TODO : comment

Parameters:

	workspace
	var_name
	array_ptr

Returns:

Definition at line 2300 of file mexlib.c.

References arr2num(), and PutVar.

{
  /*  workspace ignored: to be done .... */
  PutVar( arr2num( array_ptr) , var_name);
  return 0;  /* CHECK THIS !!!!!! */
}

Here is the call graph for this function:

void mxAssert	(	int	expr,
		char *	error_message
	)

TODO : comment

Parameters:

	expr
	error_message

Definition at line 919 of file mexlib.c.

References mexErrMsgTxt().

{
  if (!expr) mexErrMsgTxt(error_message);
}

Here is the call graph for this function:

int C2F() mxcopycomplex16toptr	(	double *	y,
		mxArray *	ptr,
		mxArray *	pti,
		integer *	n
	)

TODO : comment

Parameters:

	y
	ptr
	pti
	n

Returns:

Definition at line 2845 of file mexlib.c.

References C2F, dcopy(), and value.

{
  int one=1; int two=2;
  double *value = ((double *) *ptr);  
  double *headerm = ((double *) *pti);
  C2F(dcopy)(n,y,&two,value,&one);
  C2F(dcopy)(n,++y,&two,headerm,&one);
  return 0;
}

Here is the call graph for this function:

int C2F() mxcopyptrtocomplex16	(	mxArray *	ptr,
		mxArray *	pti,
		double *	y,
		integer *	n
	)

TODO : comment

Parameters:

	ptr
	pti
	y
	n

Returns:

Definition at line 2863 of file mexlib.c.

References C2F, dcopy(), and value.

{
  int one=1; int two=2;
  double *value = ((double *) *ptr);
  double *headerm = ((double *) *pti);
  C2F(dcopy)(n,value,&one,y,&two);
  C2F(dcopy)(n,headerm,&one,++y,&two);
  return 0;
}

Here is the call graph for this function:

mxArray* mxCreateData

(

int

m

)

TODO : comment

Parameters:

m

Returns:

Definition at line 414 of file mexlib.c.

References AsIs, C2F, createvar(), L, lr, mexErrMsgTxt(), Nbvars, and size.

                     : create a no-header, unpopulated  *
      * mxArray of size=m*sizeof(double)               */
{
  static int lw, lr;
  int n; int size;
  lw = Nbvars + 1;
  size=m-2;
  if (! C2F(createvar)(&lw, "d", &size, (n=1,&n), &lr, 1L)) {
    mexErrMsgTxt("No more memory available: increase stacksize");
  }
  C2F(intersci).ntypes[lw-1]=AsIs;
  return (mxArray *) C2F(intersci).iwhere[lw-1];
}

Here is the call graph for this function:

mxArray* C2F() mxcreatedoublematrix	(	int *	m,
		int *	n,
		int *	it
	)

TODO : comment

Parameters:

	m
	n
	it

Returns:

Definition at line 2784 of file mexlib.c.

{
  return (mxArray *) mxCreateDoubleMatrix(*m, *n, (mxComplexity)*it);
} 

mxArray* mxCreateLogicalMatrix	(	int	m,
		int	n
	)

TODO : comment

Parameters:

	m
	n

Returns:

Definition at line 1910 of file mexlib.c.

References C2F, CreateData, GetData(), iwhere, LOGICAL, and Nbvars.

{
  int new, k; int *header;
  Nbvars++;
  new=Nbvars;
  CreateData(new, (3+m*n)*sizeof(int));
  header =  (int *) GetData(new);
  header[0]=LOGICAL;
  header[1]= m; 
  header[2]= n; 
  for (k=0; k<m*n; k++) 
    header[3+k]= 0;
  return (mxArray *) C2F(intersci).iwhere[new-1]; 
}

Here is the call graph for this function:

mxArray* mxCreateLogicalScalar

(

mxLOGICAL *

value

)

TODO : comment

Parameters:

value

Returns:

Definition at line 1925 of file mexlib.c.

References mxCreateLogicalMatrix(), and stkptr().

{
  mxArray *pa; int *header;
  pa = mxCreateLogicalMatrix(1, 1);
  header = (int *) stkptr((long int) pa);
  header[3]=(int) value;
  return (mxArray *) pa;
}

Here is the call graph for this function:

const char* mxGetClassName

(

const mxArray *

ptr

)

TODO : comment

Parameters:

ptr

Returns:

Definition at line 2403 of file mexlib.c.

References CELL, DOUBLEMATRIX, Header(), INTMATRIX, MLIST, NDARRAY, SPARSEMATRIX, STRINGMATRIX, STRUCT, and theMLIST().

{
  int *header = Header(ptr);
  switch (header[0]) {
  case DOUBLEMATRIX: 
    return "double";
  case STRINGMATRIX:
    return "char";
  case SPARSEMATRIX:
    return "sparse";
  case INTMATRIX:
    /*[8,m,n,it] it=01    02   04    11     12    14
                   int8 int16 int32 uint8 uint16 uint32    */
    switch (header[3]){
    case 1:
      return "int8";
    case 2:
      return "int16";
    case 4:
      return "int32";
    case 11:
      return "uint8";
    case 12:
      return "uint16";
    case 14:
      return "uint32";
    default:
      return "unknown";
    }
  case MLIST:
    /* to be done return mxCELL_CLASS or mxCHAR_CLASS or mxSTRUCT_CLASS */
    /* header[6+2*(header[4]-1)]   ( = 1, 10, 8)  */
    switch (theMLIST(header)) {
    case CELL:
      return "cell";
    case STRUCT:
      return "struct";
    case NDARRAY:
    switch (header[6+2*(header[4]-1)]) {
      /* listentry(header,3) */
    case DOUBLEMATRIX:
      return "double";
    case STRINGMATRIX:
      return "char";
    case INTMATRIX:
      switch (header[6+2*(header[4]-1)+3]) {
      case 1:
        return "int8";
      case 2:
        return "int16";
      case 4:
        return "int32";
      case 11:
        return "uint8";
      case 12:
        return "uint16";
      case 14:
        return "uint32";
      default:
        return "unknown";
      }
    }
    default:
      return "unknown";
    }
  }
  return "unknown";
}

Here is the call graph for this function:

bool mxIsLogicalScalar

(

mxArray *

pa

)

TODO : comment

Parameters:

pa

Returns:

Definition at line 1942 of file mexlib.c.

References mxGetNumberOfElements(), and mxIsLogical().

{
  bool retval;
  retval = mxIsLogical(pa) && mxGetNumberOfElements(pa) == 1;
  return retval;
}

Here is the call graph for this function:

bool mxIsLogicalScalarTrue

(

mxArray *

pa

)

TODO : comment

Parameters:

pa

Returns:

Definition at line 1934 of file mexlib.c.

References mxGetLogicals(), mxGetNumberOfElements(), and mxIsLogical().

{
  bool retval;
  retval = mxIsLogical(pa) && mxGetNumberOfElements(pa) == 1 && *mxGetLogicals(pa) == 1;
  return retval;
}

Here is the call graph for this function:

void* mxRealloc	(	void *	ptr,
		size_t	nsize
	)

TODO : comment

Parameters:

	ptr
	nsize

Definition at line 1321 of file mexlib.c.

References C2F, createstkptr(), m, memcpy(), mxFree(), and NULL.

{
  int m;  vraiptrst lrd=(vraiptrst)NULL; 
  m = (nsize) /sizeof(double) + 1;
  mxFree((void *) lrd);
  if (! C2F(createstkptr)( &m, &lrd)) return 0;
  memcpy((void *) lrd, ptr, nsize);
  return (void *) lrd;
}

Here is the call graph for this function:

void numberandsize	(	const mxArray *	ptr,
		int *	number,
		int *	size
	)

TODO : comment

Parameters:

	ptr
	number
	size

Definition at line 1594 of file mexlib.c.

References bot, C2F, lstk, Lstk, Nbvars, Rhs, and Top.

                    : its number as scilab variable 
      * and its size in Scilab double stack */
{
  int kk,lst_k;
  lst_k=(int) ptr;
  if (lst_k < *Lstk(C2F(vstk).bot)) {
    *number=0;*size=0;
  for (kk = 1; kk <= Nbvars; kk++)
    {
      *number=kk;
      if (lst_k == C2F(vstk).lstk[kk+ Top - Rhs -1]) break;
    }
  *size = C2F(vstk).lstk[*number+ Top - Rhs] - lst_k;
  } else
    {
    *number=0;
  for (kk = C2F(vstk).bot; kk <  C2F(vstk).isiz; kk++)
    {
      *number=kk;
      if (lst_k == C2F(vstk).lstk[kk-1]) break;
    }
  *size = C2F(vstk).lstk[*number] - lst_k;
    }
}

int* RawHeader

(

const mxArray *

ptr

)

TODO : comment

Parameters:

ptr

Returns:

Definition at line 392 of file mexlib.c.

References stkptr().

{
  /* Utility function : return an integer pointer to   *
   * a Scilab variable. The variable can be            *
   * a reference (header[0] < 0)                       */
  int *header = (int *) stkptr((long int)ptr);
  return header;
}

Here is the call graph for this function:

vraiptrst stkptr

(

long int

ptr_lstk

)

TODO : comment

Parameters:

ptr_lstk

Returns:

Referenced by Header(), header2ptr(), initmex(), mxCreateLogicalScalar(), mxgetm(), mxgetn(), mxgetpi(), mxgetpr(), mxgetscalar(), mxgetstring(), mxiscomplex(), mxisfull(), mxisnumeric(), mxissparse(), mxisstring(), mxSetM(), mxSetN(), mxSetNzmax(), and RawHeader().

Here is the caller graph for this function:

int theMLIST

(

int *

header

)

TODO : comment

Parameters:

header

Returns:

Definition at line 138 of file mexlib.c.

References l, listentry(), MLIST, and STRINGMATRIX.

{
  /* Returns the type of the mlist  (CELL, STRUCT or HYPERMATRIX)  */
  int *header1; int nfplus2, l;
  if (header[0]==MLIST && header[1]==3 && header[6]==STRINGMATRIX) {
    if (header[14]==12 && header[15]==14) return 2;  /* CELL "c"=12 "e"=14  */
    if (header[14]==17 && header[15]==22) return 1;  /* NDARRAY "h"=17 "m"=22   */
  }
  if (header[0]==MLIST) {
    header1 = (int *) listentry(header,1);
    nfplus2 = header1[1]*header1[2];
    l = 5 + nfplus2;
  /*  "s"=28,  "t"=29   */
    if (header1[0]==STRINGMATRIX && header1[l]==28 && header1[l+1]==29) return 3;  /* STRUCT */
  }
  return 0;
}

Here is the call graph for this function:

mxArray* UnrefStruct

(

mxArray *

ptr

)

Unreference objects in a struct or cell

Parameters:

ptr

Returns:

Definition at line 1712 of file mexlib.c.

References Bot, Error, Header(), listentry(), Lstk, mxDuplicateArray(), nb, numberandsize(), offset, Rhs, stk, and Top.

{
  /*   Unreference objects in a struct or cell */
  int number, k;
  int list, lindex, offset; int sizeobj;
  int nb, nbobj, suite, newbot;

  int oldsize, newsize;

  int *header, *headernew;
  int *headerlist, *headerlistnew; 
  int *headerobj, *headerobjnew;
  int *headerdims; int proddims;int obj;

  mxArray *mxNew;
  header = Header(ptr);   /* RawHeader ?  */
  mxNew = mxDuplicateArray(ptr);
  headernew = Header(mxNew);   /* RawHeader ?  */
  
  offset = Top - Rhs;
  newsize=header[4];   /* Initialize */
  nb=header[1]-2;      /* Number of fields  */
  headerdims = listentry(header,2);
  proddims=1;
  for (k=0; k<headerdims[1]*headerdims[2]; k++) {
    proddims=proddims*headerdims[4+k];
  }
  if (!(proddims==1)) {
    suite=0;
    for (list=0; list<nb; list++) {
      headerlist= listentry(header, list+3);  /* pointing to the field list */
      nbobj=headerlist[1];   /* number of objects in the field */
      for (lindex=0; lindex < nbobj; lindex++)
        {
          headerobj = listentry( headerlist,lindex+1);  
          /* pointing to the object in the field */
          if (headerobj[0] < 0)
            sizeobj=headerobj[3];
          else
            sizeobj=headerlist[lindex+3]-headerlist[lindex+2];
          newsize += sizeobj;   /* update size of the field */
        }
      suite++;
      newsize += (2+nbobj/2);   /* size of list = size of inside + ... */
      headernew[4+suite] = newsize;
    }
    numberandsize( mxNew, &number, &oldsize);
    newsize += 3;   /* taking account begining of list */
    newbot=*Lstk(number+offset)+newsize+1;
    if( (newbot - *Lstk(Bot)) > 0) 
      {Error(17); return 0;}
    *Lstk(number+offset+1)=newbot;
    for (list=0; list<nb; list++) {
      headerlist= listentry(header, list+3);
      headerlistnew=listentry(headernew, list+3);
      nbobj=headerlist[1]; 
      headerlistnew[0]= 15;
      headerlistnew[1]= nbobj;
      headerlistnew[2]= 1;
      for (lindex=0; lindex < nbobj; lindex++)
        {       headerobj = listentry( headerlist,lindex+1);
        if (headerobj[0] < 0)
          sizeobj=headerobj[3];  /* reference (size of ) */
        else
          sizeobj=headerlist[lindex+3]-headerlist[lindex+2];
        headerlistnew[3+lindex]=headerlistnew[2+lindex]+sizeobj;
        }
    }
    for (list=0; list<nb; list++) {
      headerlist= listentry(header, list+3);
      headerlistnew=listentry(headernew, list+3);
      nbobj=headerlist[1]; 
      for (lindex=0; lindex < nbobj; lindex++)
        {       
          headerobj = listentry( headerlist,lindex+1);
          headerobjnew = listentry( headerlistnew,lindex+1);    
          if (headerobj[0] < 0)   /* reference */
            {
              sizeobj=headerobj[3];
              headerobj = (int *) stk(headerobj[1]);   /* dereference */
            }
          else
            {
              sizeobj=headerlist[lindex+3]-headerlist[lindex+2];
            }
          for (k=0; k<2*sizeobj; k++)
            headerobjnew[k]=headerobj[k];  /* OUF! */
        }
    }
  }
  else {
    /*   1 x 1 x ... x 1 struct */
    suite=0;
    for (obj=0; obj<nb; obj++) {
      headerobj = listentry(header,3+obj);
      if (headerobj[0] < 0)
        sizeobj=headerobj[3];
      else
        sizeobj = header[5+obj] - header[4+obj];
      newsize += sizeobj;
    suite++;
    newsize += sizeobj;
    headernew[4+suite]=newsize;
    }
    numberandsize( mxNew, &number, &oldsize);
    newsize +=3;
    newbot = *Lstk(number+offset)+newsize+1;
    if ( (newbot - *Lstk(Bot)) > 0)
      {Error(17); return 0;}
    *Lstk(number+offset+1)=newbot;
    for (obj=0; obj<nb; obj++)
      {
        headerobj = listentry(header, 3+obj);
        headerobjnew = listentry(headernew, 3+obj);
        if (headerobj[0] < 0)
          {
            sizeobj=headerobj[3];
            headerobj = (int *) stk(headerobj[1]);
          }
        else
          {
            sizeobj=header[5+obj]-header[4+obj];
          }
        for (k=0; k<2*sizeobj; k++)
          headerobjnew[k]=headerobj[k];
      }
  }
  return mxNew;
}

Here is the call graph for this function:

---