#endif

 
/* For math library use only.  Do not call this function.*/
extern int mclExpandVararginList(mxArray ***prhs, int size, mxArray **prhslocal);

extern int mclUnpackCommaList(mxArray **prhs, mxArray *m, bool to_cell, bool is_cpp_array);

 
/* For math library use only.  Do not call this function.*/
extern mxArray *mclUnpackVararginToCell(int nrhs, mxArray **prhs);


extern void mclVarargin(mxArray ** varargin, mxArray * last, int uselast, va_list ap);


extern int mlfCountVarargin(va_list ap, mxArray *first);


/* For math library use only.  Do not call this function.*/
extern void mlfUnpackVarargin(va_list ap, mxArray **prhs, mxArray *first);

extern mxArray *mlfCellhcat(mxArray *pa, ...);

extern void mlxCellhcat(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs);

extern int mclNargin(int nargs, ...);


typedef struct mlfVarargoutList_tag mlfVarargoutList;

extern int mclNargout(mlfVarargoutList *varargout);

extern mlfVarargoutList *mlfIndexVarargout(mxArray **ppa, ...);

extern mlfVarargoutList *mlfVarargout(mxArray **ppa, ...);

extern mxArray *mlfGetVarargoutCell(mlfVarargoutList *v);

extern mxArray **mlfGetVarargoutCellPtr(mlfVarargoutList *v);

extern mlfVarargoutList *mclAnsVarargout(void);

extern mlfVarargoutList *mclNVarargout(int nargout, int varargout_used, ...);

extern mlfVarargoutList *mclValueVarargout(void);

extern mxArray *mlfAssignOutputs(mlfVarargoutList *v);

extern void mclCreateVarargoutCell(mlfVarargoutList *vout, int nvarargs, mxArray **ppa);


extern void mclAssignVarargoutCell(int offset, int nlhs, mxArray *plhs[], mxArray *cell);


extern mxArray *mclCreateVararginCell(int nrhs, mxArray *prhs[]);


typedef void (*mlfFcnPtr)(int, mxArray**, int, mxArray**);



typedef struct mlfDispatchTable_tag 
{
  mlfFcnPtr *vtab;
  const char** funcnames;
  int nfuncs;
} mlfDispatchTable;



#define MLF_DEFAULT_INDEX_SIZE 4

typedef unsigned char mlfIndexType;
struct mlfIndexDef_tag
{
    int num_index_ops;
    mlfIndexType *type;
    int *idx;
    mxArray **subscripts;
    int  *fieldptrs;
    char *fieldnames;
    mlfIndexType type_local[MLF_DEFAULT_INDEX_SIZE];
    int idx_local[MLF_DEFAULT_INDEX_SIZE+1];
    mxArray *subscripts_local[MLF_DEFAULT_INDEX_SIZE];
    int fieldptrs_local[MLF_DEFAULT_INDEX_SIZE+1];
    char fieldnames_local[MLF_DEFAULT_INDEX_SIZE];
    mxArray **dest;
    int size;
    int max_size;
    mxArray *lastref;
};
#define mlfCELL 0
#define mlfARRAY 1
#define mlfSTRUCT 2
typedef struct mlfIndexDef_tag mlfIndexDef;


/* For use only by the C++ math library. Do not call this function. */
extern void mclInitIndex(mlfIndexDef *index_def);

extern mlfIndexDef *mclCreateIndexDef(void);

 
extern void mclSetDest(mlfIndexDef *result, mxArray **ip);

extern void mclDestroyIndexDef(mlfIndexDef *index_def, int free_flag);

extern void mclCopyIndexDef(mlfIndexDef *dest, const mlfIndexDef *src);


/* For use only by the C++ math library. Do not call this function. */
extern void mclAddIndex(mlfIndexDef *index_def, mlfIndexType type1, int nsubscripts, mxArray **psubscripts);


extern void mclAddFieldToLastIndex(mlfIndexDef *index_def, const char* fname_in);


/* For use only by the C++ math library. Do not call this function. */
extern mxArray *mclComplexRef(mxArray *pa, mlfIndexDef *index_def);

 
/* This function is intended for use only by the C++ math library */
extern void mclComplexAssign(mlfIndexDef *index_def, mxArray *src, bool packCell, bool do_scalar_assign);

extern void mclPrintIndex(const char* index_string, ...);

extern mxArray * mlfIndexRef(mxArray *pa, const char* index_string, ...);

extern mxArray * mlfIndexAssign(mxArray * volatile *pa, const char* index, ...);

extern mxArray * mlfIndexDelete(mxArray * volatile *pa, const char* index, ...);

extern mxArray* mlfArrayRef(mxArray *array, ...);

extern void mlfArrayAssign(mxArray *dest, mxArray *src, ...);

extern void mlfArrayDelete(mxArray *dest, ...);

extern mxArray * mlfCreateColonIndex( void );

extern bool mlfIsColonIndex(mxArray *a);


extern int mclGetNumberOfIndexedElements(mlfIndexDef *index_def);


/* For use only by the C++ math library */
extern int mclMultiAssign(mlfIndexDef *index_def, mxArray **prhs, int max_rhs_size);


extern mxArray *mclArrayRef1( mxArray *pa, mxArray *sub );


extern mxArray *mclArrayRef2( mxArray *pa, mxArray *sub1, mxArray *sub2 );


extern mxArray *mclIntArrayRef1( mxArray *pa, int sub );


extern mxArray *mclIntArrayRef2( mxArray *pa, int sub1, int sub2 );


extern void mclArrayAssign1( mxArray **dest, mxArray *src, mxArray *sub );


extern void mclArrayAssign2( mxArray **dest, mxArray *src, mxArray *sub1,  mxArray *sub2 );


extern void mclIntArrayAssign1( mxArray **dest, mxArray *src, int sub );


extern void mclIntArrayAssign2( mxArray **dest, mxArray *src, int sub1, int sub2 );

extern void *mclMalloc(size_t s);

extern void *mclCalloc(size_t c, size_t s);

extern void *mclRealloc(void *p, size_t s);



#ifdef mxMalloc
#undef mxMalloc
#endif
#define mxMalloc mclMalloc

#ifdef mxCalloc
#undef mxCalloc
#endif
#define mxCalloc mclCalloc

#ifdef mxRealloc
#undef mxRealloc
#endif
#define mxRealloc mclRealloc


extern int mclUnshareArray(mxArray *pa, int level);


#ifdef mxUnshareArray
#undef mxUnshareArray
#endif
#define mxUnshareArray mclUnshareArray

extern mxArray *mclCreateCellArray(int ndim, const int *dims);


#ifdef mxCreateCellArray
#undef mxCreateCellArray
#endif
#define mxCreateCellArray mclCreateCellArray

extern mxArray *mclCreateCharMatrixFromStrings(int m, const char **str);


#ifdef mxCreateCharMatrixFromStrings
#undef mxCreateCharMatrixFromStrings
#endif
#define mxCreateCharMatrixFromStrings mclCreateCharMatrixFromStrings

extern mxArray *mclCreateDoubleMatrix(int m, int n, mxComplexity ComplexFlag);


#ifdef mxCreateDoubleMatrix
#undef mxCreateDoubleMatrix
#endif
#define mxCreateDoubleMatrix mclCreateDoubleMatrix

extern mxArray *mclCreateNumericArray(int ndim, const int *dims, 
                                      mxClassID clsid, mxComplexity ComplexFlag);


#ifdef mxCreateNumericArray
#undef mxCreateNumericArray
#endif
#define mxCreateNumericArray mclCreateNumericArray

extern mxArray *mclCreateSparse(int m, int n, int nzmax, 
                                mxComplexity ComplexFlag);


#ifdef mxCreateSparse
#undef mxCreateSparse
#endif
#define mxCreateSparse mclCreateSparse

extern mxArray *mclCreateString(const char *str);


/* macro proto: mxArray* mxCreateString(char* arg); */
#ifdef mxCreateString
#undef mxCreateString
#endif
#define mxCreateString mclCreateString

extern mxArray *mclCreateStructArray(int ndim, const int *dims, int nfields,
                                    const char **field_names);


#ifdef mxCreateStructArray
#undef mxCreateStructArray
#endif
#define mxCreateStructArray mclCreateStructArray

extern mxArray *mclCreateStructMatrix(int m, int n, int nfields, 
                                      const char **field_names);


#ifdef mxCreateStructMatrix
#undef mxCreateStructMatrix
#endif
#define mxCreateStructMatrix mclCreateStructMatrix

extern mxArray *mclDuplicateArray(const mxArray *in);


#ifdef mxDuplicateArray
#undef mxDuplicateArray
#endif
#define mxDuplicateArray mclDuplicateArray

extern mxArray *mclGetCell(const mxArray *array_ptr, int index);


#ifdef mxGetCell
#undef mxGetCell
#endif
#define mxGetCell mclGetCell

extern void *mclGetData(const mxArray *array_ptr);


#ifdef mxGetData
#undef mxGetData
#endif
#define mxGetData mclGetData

extern mxArray *mclGetField(const mxArray *array_ptr, int index, 
                            const char *field_name);


#ifdef mxGetField
#undef mxGetField
#endif
#define mxGetField mclGetField

extern mxArray *mclGetFieldByNumber(const mxArray *array_ptr, int index, 
                                   int field_number);


#ifdef mxGetFieldByNumber
#undef mxGetFieldByNumber
#endif
#define mxGetFieldByNumber mclGetFieldByNumber

extern void *mclGetImagData(const mxArray *array_ptr);


#ifdef mxGetImagData
#undef mxGetImagData
#endif
#define mxGetImagData mclGetImagData

extern int *mclGetIr(const mxArray *array_ptr);


#ifdef mxGetIr
#undef mxGetIr
#endif
#define mxGetIr mclGetIr

extern int *mclGetJc(const mxArray *array_ptr);


#ifdef mxGetJc
#undef mxGetJc
#endif
#define mxGetJc mclGetJc

extern double *mclGetPr(const mxArray *array_ptr);


#ifdef mxGetPr
#undef mxGetPr
#endif
#define mxGetPr mclGetPr

extern double *mclGetPi(const mxArray *array_ptr);


#ifdef mxGetPi
#undef mxGetPi
#endif
#define mxGetPi mclGetPi

extern void mclSetCell(mxArray *array_ptr, int index, mxArray *value);


#ifdef mxSetCell
#undef mxSetCell
#endif
#define mxSetCell mclSetCell

extern void mclSetData(mxArray *array_ptr, void *data_ptr);


#ifdef mxSetData
#undef mxSetData
#endif
#define mxSetData mclSetData

extern int mclSetDimensions(mxArray *array_ptr, const int *dims, int ndims);


#ifdef mxSetDimensions
#undef mxSetDimensions
#endif
#define mxSetDimensions mclSetDimensions

extern void mclSetField(mxArray *array_ptr, int index, 
                        const char *field_name, mxArray *value);


#ifdef mxSetField
#undef mxSetField
#endif
#define mxSetField mclSetField

extern void mclSetFieldByNumber(mxArray *array_ptr, int index, 
                               int field_number, mxArray *value);


#ifdef mxSetFieldByNumber
#undef mxSetFieldByNumber
#endif
#define mxSetFieldByNumber mclSetFieldByNumber

extern void mclSetImagData(mxArray *array_ptr, void *pi);


#ifdef mxSetImagData
#undef mxSetImagData
#endif
#define mxSetImagData mclSetImagData

extern void mclSetIr(mxArray *array_ptr, int *ir);


#ifdef mxSetIr
#undef mxSetIr
#endif
#define mxSetIr mclSetIr

extern void mclSetJc(mxArray *array_ptr, int *jc);


#ifdef mxSetJc
#undef mxSetJc
#endif
#define mxSetJc mclSetJc

extern void mclSetPi(mxArray *array_ptr, double *pi);


#ifdef mxSetPi
#undef mxSetPi
#endif
#define mxSetPi mclSetPi

extern void mclSetPr(mxArray *array_ptr, double *pr);


#ifdef mxSetPr
#undef mxSetPr
#endif
#define mxSetPr mclSetPr

extern mxArray *mclCreateSharedCopy(const mxArray *pa);


#ifdef mxCreateSharedCopy
#undef mxCreateSharedCopy
#endif
#define mxCreateSharedCopy mclCreateSharedCopy


#include "mex.h"
#undef printf

typedef void (*mlfFuncp)( void );

typedef int (*mlfThunkp)( mlfFuncp pFunc, int nlhs, mxArray **plhs, int nrhs, mxArray **prhs );

typedef struct {
    char *name;
    mlfFuncp pFunc;
    mlfThunkp pThunk;
} mlfFuncTabEnt;

typedef mlfFuncTabEnt mlfFuncTab;  /* Table is just an array of entries */


extern mexLocalFunctionTable mclSetCurrentLocalFunctionTable(mexLocalFunctionTable lft);


extern mxFunctionPtr 
mclFevalLookup( mxArray* fcn );


extern mxFunctionPtr 
mlfFevalLookup(mxArray *fcn);


/*
 *  General call to another mexfile for feval.
 *  This function is identical to mlfCallMATLAB except
 *  for the "real work" section where it calls
 *  another mex file instead of mexCallMATLAB.
 */
extern void
mlfFeval_12( int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name );


extern void mlfFevalTableSetup( mlfFuncTab *mlfUfuncTable );

 
extern void mlfFunctionTableSetup(size_t size, mexFunctionTable pTab);

 
extern void mlfFunctionTableTakedown(size_t size, mexFunctionTable pTab);