libmatlb.h

VC调用MATLAB编译的D

/*
 * Used by C++ math library.
 */
extern void mclFevalArray( int nlhs, mxArray **plhs, int nrhs, mxArray **prhs );


extern void mclMlxFeval( int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, mxFunctionPtr mxfn, bool builtin );

 
extern mxArray * mclFeval(mlfVarargoutList *varargout, mxFunctionPtr mxfn, ...);

 
extern mxArray * mlfFeval(mlfVarargoutList *varargout, ...);


extern void mlxFeval( int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[] );

 
extern mxArray * mlfBuiltin(mlfVarargoutList *varargout, ...);


extern void mlxBuiltin( int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);


extern mxArray * mclCreateSimpleFunctionHandle(mxFunctionPtr f, const char *name);

 
extern void mcl_eval_string_fcn( int nlhs, mxArray **plhs, const char *str, 
                          mxFunctionPtr (*lookup)(char* name, void *lookup_x), void *lookup_x );


extern void
mclEvalString(  int nlhs, mxArray **plhs, const char *str );


extern void mclAddPaths( size_t num_paths, const char **paths );


extern bool mclFindFirstFileName(
    const char	*name,
    bool	supply_matlab_exts,
    char	*fullname
    );


extern void mclInitMatlabRoot( int *argc, const char **argv );


extern void mclInitDLLMatlabRoot( void *hinst );


extern double mclDivideDouble(double x, double y);


extern double mclLeftDivideDouble(double x, double y);


extern mxArray *mclDivideDoublePair(double x1, double x2, double y1, double y2);


extern mxArray *mclLeftDivideDoublePair(double x1, double x2, double y1, double y2);


extern int mclLengthInt(mxArray *a);


extern double mclPowerDouble(double b, double x);


/* macro proto: mxArray* mclInitializeAns(); */
#define mclInitializeAns() NULL
#define mclInitializeNull() NULL
#define mclIsInitialized(pa) (pa != NULL)

extern mxArray *mlfReturnValue(mxArray *a);

 
extern bool mclUninitWarning( const char *vname );


typedef enum mclValidateErrorCode {
  mclINPUT_UNDEFINED=0,
  mclFCN_OR_VARIABLE_UNDEFINED
} mclValidateErrorCode;


/* macro proto: mxArray* mclVa(mxArray* in, char* vname); */
/* macro proto: mxArray* mclVv(mxArray* in, char* vname); */
/* macro proto: mxArray* mclVg(mxArray* in, char* vname); */

#define mclVva( in, errcode, vname )                            \
( in != NULL ? in : mclValidateError( errcode, vname ) )

#define mclVa(in, vname) mclVva(in, mclINPUT_UNDEFINED, vname)

#define mclVv(in, vname) mclVva(in, mclFCN_OR_VARIABLE_UNDEFINED, vname)


 
extern mxArray *mclValidateError( mclValidateErrorCode code, const char *vname );


extern mxArray *mclVe( mxArray *in );


extern void mclCopyInputArg( mxArray * volatile *dest, mxArray *src );

 
extern void mclCopyArray( mxArray **pa );


extern void mclCopyOutputArg(mxArray * volatile *dest, mxArray *src);


extern void mclValidateOutputWarning( const char *vname, const char *fname );


extern void mclValidateOutputError( const char *vname, const char *fname );



/* macro proto: void mclValidateOutput(mxArray*, int, int, char*, char*); */

#define mclValidateOutput( output, pos, nargout, vname, fname ) \
{                                                               \
  if ( pos <= nargout && output == NULL ) {                     \
    mclValidateOutputError( vname, fname );                     \
  }                                                             \
} (void)0


extern mxArray ** mclInitGlobal( mxArray **g );


/* macro proto: mxArray** mclPrepareGlobal(mxArray** g); */
#define mclPrepareGlobal(g) ((*g != NULL) ? g : mclInitGlobal(g))


extern mxArray *mclVg( mxArray **pg, const char *name );


/* Common definitions */
#define mclAppendMlineCommon()                                  \
      mclAppendMlineToError( (const char *) __M_file_name,      \
                             (const char *) __M_function_name,  \
                             (size_t) __M_line_number );

#define mclMlineEnterFunctionCommon(file_name, function_name )  \
{ const char * volatile __M_file_name = file_name;              \
  const char * volatile __M_function_name = function_name;      \
  volatile size_t __M_line_number = 0; 


#define mclMlineEnterFunction( file_name, function_name )       \
  mclMlineEnterFunctionCommon( file_name, function_name )       \
  mlfTry {

#define mclMlineExitFunctionCommon()            \
      mclAppendMlineCommon()                    \
      mclRethrowLastError();                    \
  } mlfEndCatch } return

#define mclMlineExitFunction()                  \
  } mlfCatch {                                  \
  mclMlineExitFunctionCommon()

#define mclMlineFunctionReturn()  mclExitTryBlock_();
#define mclMlineExitFunctionReturn()                            \
   } mclCatchWithoutExit { mclMlineExitFunctionCommon() NULL

#define mclMline( line ) __M_line_number = line;

#define mclRethrowLastError()                           \
{                                                       \
    mxArray * lastid = NULL, * lastmsg;                 \
    mxArray * fmt;                                      \
                                                        \
    mlfInitFcn();                                       \
    fmt = mxCreateString("%s");                         \
                                                        \
    lastmsg = mlfLasterr(&lastid, NULL, NULL);          \
                                                        \
    if (mxGetNumberOfElements(lastid) > 0)              \
        mlfError(lastid, fmt, lastmsg, NULL);           \
    else                                                \
        mlfError(fmt, lastmsg, NULL);                   \
}



extern void mclAppendMlineToError(const char *file_name, const char *function_name, size_t line_number );


typedef void (*fn_mcl_assign_global)( void *X, mxArray *new_value );


typedef mxArray *(*fn_mcl_get_global)( void *X );


extern void mclSetMexGlobalCallbacks( fn_mcl_assign_global assign_global,
                               fn_mcl_get_global get_global );


extern void mclInsertGlobal( void *g, const char *gname );


extern void mclMexInitGlobals( mex_information info );


extern mxArray * mclExecMexFile( mlfVarargoutList *varargout,
                          const char *name, ...);


extern mxArray * mclCExecMexFunction(const char * fcn_name, int nargout_, mxArray * varargin);


extern void mclFixArrayRef( mxArray *pa );


extern mxArray *mclInitializeDouble( double d );


extern mxArray *mclInitializeComplex( double re, double im );


extern mxArray *mclInitializeComplexVector( int m, int n, double *pr, double *pi );


extern mxArray *mclInitializeDoubleVector( int m, int n, double *pr );


extern mxArray *mclInitializeString( int len, mxChar *string_pr );


extern mxArray *mclInitializeCharVector( int m, int n, mxChar *string_pr );


extern mxArray *mclInitializeCell( mxArray *cell );

 
extern mxArray *mclInitializeCellVector( int m, int n, mxArray **cell_pr );


extern mxArray *mclInitializeOther( unsigned char *buf, size_t size );


extern void mclInitializePersistent(mxArray* volatile * pv);


extern mxArray *mclInitializeLogical( bool b );


extern mxArray *mclInitializeLogicalVector( int m, int n, mxLogical *pl );


typedef enum {mclFOR_COLON, mclFOR_NUMERIC, mclFOR_GENERIC} mclForLoopCategory;

typedef struct _mclForLoopIterator mclForLoopIterator;

typedef void (*fn_for_next)( mclForLoopIterator *iter, mxArray * index );

/* For use only by the Matlab compiler. */
struct _mclForLoopIterator {
  int curridx;  /* Current index into loop array */
  int maxidx;   /* number of times to repeat the loop */
  mclForLoopCategory category;
  fn_for_next start;
  fn_for_next next;
  union {
    struct {
      int m;
      unsigned char scalar;
      unsigned char logical;
      void *pr;
      void *pi;
      int nel;
      mxArray *loop_array;  /* array over which we are iterating, (null if colon index) */
    } num;
    struct {
      double start; /* start value (ignored if not colon) */ 
      double delta; /* step value (ignored if not colon) */ 
    } colon;
    struct {
      mxArray *loop_array;  /* array over which we are iterating, (null if colon index) */
      mxArray *row; /* row index (null if colon index) */ 
      mxArray *col; /* column index (null if colon index)*/
    } arr;
  } iter;
};

#define mclForDone 0

 
/* For use only by the Matlab compiler.  Do not call this function. */
extern void mclDestroyForLoopIterator_(mclForLoopIterator *iter);


/* macro proto: void mclDestroyForLoopIterator(mclForLoopIterator *iter) */
#define mclDestroyForLoopIterator(x) mclDestroyForLoopIterator_(&x)

 
/* For use only by the Matlab compiler.  Do not call this function. */
extern void mclForStart(mclForLoopIterator *iter, mxArray *pa, mxArray *pa2, mxArray *pa3);


typedef mxArray * volatile *mclVolatileArrayPtr;

 
/* For use only by the Matlab compiler.  Do not call this function. */
extern int mclForNext(mclForLoopIterator *iter, mclVolatileArrayPtr ppa);


/* For use only by the Matlab compiler.  Do not call this function. */
/*
 * The purpose of this function is to ensure that a value of INT_MIN for
 * the upper bound of a loop always causes a null loop.  This is true as
 * long as the start of the loop is not exactly INT_MIN.
 */
extern int mclForIntStart(int s);


/* For use only by the Matlab compiler.  Do not call this function. */
/*
 * The next two functions are based on mxColonop_size for integer values of
 * what are there called a and d.
 */
extern int mclForIntEnd(mxArray *e); /* The increment is implicitly 1 */


/* For use only by the Matlab compiler.  Do not call this function. */
/*
 * When comparing to mxColonop_size, s corresponds to a, and i to d.
 * This returns the exact endpoint, so termination can be done by equality,
 * independently of the sign of i.
 */
extern int mclForIntIntEnd(int s, int i, mxArray *e);


extern mxArray *mclPlus( mxArray *a, mxArray *b );


extern mxArray *mclMinus( mxArray *a, mxArray *b );


extern mxArray *mclTimes( mxArray *a, mxArray *b );


extern mxArray *mclMtimes( mxArray *a, mxArray *b );


extern mxArray *mclRdivide( mxArray *a, mxArray *b );


extern mxArray *mclMrdivide( mxArray *a, mxArray *b );


extern mxArray *mclMpower( mxArray *a, mxArray *b );


extern mxArray *mclEq( mxArray *a, mxArray *b );


extern mxArray *mclNe( mxArray *a, mxArray *b );


extern mxArray *mclLt( mxArray *a, mxArray *b );


extern mxArray *mclGt( mxArray *a, mxArray *b );


extern mxArray *mclLe( mxArray *a, mxArray *b );


extern mxArray *mclGe( mxArray *a, mxArray *b );


extern mxArray *mclAnd( mxArray *a, mxArray *b );


extern mxArray *mclOr( mxArray *a, mxArray *b );


extern mxArray *mclUplus( mxArray *a );


extern mxArray *mclUminus( mxArray *a );


extern mxArray *mclNot( mxArray *a );


extern bool mclEqBool( mxArray *a, mxArray *b );


extern bool mclNeBool( mxArray *a, mxArray *b );


extern bool mclLtBool( mxArray *a, mxArray *b );


extern bool mclGtBool( mxArray *a, mxArray *b );


extern bool mclLeBool( mxArray *a, mxArray *b );


extern bool mclGeBool( mxArray *a, mxArray *b );


extern bool mclNotBool( mxArray *a );


extern void mclAddPaths( size_t num_paths, const char **paths );


extern bool mclFindFirstFileName(
    const char	*name,
    bool	supply_matlab_exts,
    char	*fullname
    );


extern void mclInitMatlabRoot( int *argc, const char **argv );


extern void mclInitDLLMatlabRoot( void *hinst );


extern void mclLibInitGlobals(int length, mexGlobalTable globals);


extern void mclLibTermGlobals(int length, mexGlobalTable globals);


extern void mclLibInitInitTerms(int length, mexInitTermTableEntry inits);


extern void mclLibTermInitTerms(int length, mexInitTermTableEntry terms);


extern void mclLibInitCommon( mex_information info );


extern void mclLibInit(const char *name, int * ref, mex_information info);


extern void mclLibTermCommon( mex_information info );


extern void mclLibTerm(const char *name, int * ref, mex_information info);


extern int mclMain( int argc, const char **argv, mxFunctionPtr mlxfn, bool nout, mex_information info );


extern mex_information mclMex( mex_information mex_info );


extern void mclMextest( int nlhs, mxArray **plhs, int nrhs, const mxArray **prhs, mxFunctionPtr mlxF, mex_information info, const char *mfcn );


/*
 * These macros are for backward compatibility.
 */
#define mclGlobalTableEntry mexGlobalTableEntry
#define mclExportGlobal mexExportGlobal
#define mlfFunctionTableEntry mexFunctionTableEntry


extern mxArray * mclFevalCallMATLAB(mlfVarargoutList *varargout,
                               const char *name, ...);


extern int mclSupportedDataTypes(int nrhs, const mxArray **prhs);

#ifdef __cplusplus
    }	/* extern "C" */
#endif


/*
 * $Revision: 1.1 $
 */

#include "libmatlbm.h"
#include "libsgl.h"

#endif /* libmatlb_h */