www.pudn.com > vcmatlab20060426WaterMark.zip > iofun_private_bitslice_mex_interface.cpp

// 
// MATLAB Compiler: 2.2 
// Date: Tue May 10 11:47:30 2005 
// Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on" 
// "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O" 
// "array_indexing:on" "-O" "optimize_conditionals:on" "-B" "sglcpp" "-p" "-W" 
// "main" "-L" "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg" 
// "libmwsglm.mlib" "huatu"  
// 
#include "iofun_private_bitslice_mex_interface.hpp" 
 
void InitializeModule_iofun_private_bitslice_mex_interface() { 
} 
 
void TerminateModule_iofun_private_bitslice_mex_interface() { 
} 
 
static mwArray Miofun_private_bitslice(int nargout_, mwArray varargin); 
 
_mexLocalFunctionTable _local_function_table_iofun_private_bitslice 
  = { 0, (mexFunctionTableEntry *)NULL }; 
 
// 
// The function "Niofun_private_bitslice" contains the nargout interface for 
// the "iofun/private/bitslice" M-function from file 
// "D:\matlab\matlab\toolbox\matlab\iofun\private\bitslice.dll" (lines 0-0). 
// This interface is only produced if the M-function uses the special variable 
// "nargout". The nargout interface allows the number of requested outputs to 
// be specified via the nargout argument, as opposed to the normal interface 
// which dynamically calculates the number of outputs based on the number of 
// non-NULL inputs it receives. This function processes any input arguments and 
// passes them to the implementation version of the function, appearing above. 
// 
mwArray Niofun_private_bitslice(int nargout, 
                                mwVarargout varargout, 
                                mwVarargin varargin) { 
    nargout += varargout.Nargout(); 
    varargout.GetCell() = Miofun_private_bitslice(nargout, varargin.ToArray()); 
    return varargout.AssignOutputs(); 
} 
 
// 
// The function "iofun_private_bitslice" contains the normal interface for the 
// "iofun/private/bitslice" M-function from file 
// "D:\matlab\matlab\toolbox\matlab\iofun\private\bitslice.dll" (lines 0-0). 
// This function processes any input arguments and passes them to the 
// implementation version of the function, appearing above. 
// 
mwArray iofun_private_bitslice(mwVarargout varargout, mwVarargin varargin) { 
    int nargout(0); 
    nargout += varargout.Nargout(); 
    varargout.GetCell() = Miofun_private_bitslice(nargout, varargin.ToArray()); 
    return varargout.AssignOutputs(); 
} 
 
// 
// The function "Viofun_private_bitslice" contains the void interface for the 
// "iofun/private/bitslice" M-function from file 
// "D:\matlab\matlab\toolbox\matlab\iofun\private\bitslice.dll" (lines 0-0). 
// The void interface is only produced if the M-function uses the special 
// variable "nargout", and has at least one output. The void interface function 
// specifies zero output arguments to the implementation version of the 
// function, and in the event that the implementation version still returns an 
// output (which, in MATLAB, would be assigned to the "ans" variable), it 
// deallocates the output. This function processes any input arguments and 
// passes them to the implementation version of the function, appearing above. 
// 
void Viofun_private_bitslice(mwVarargin varargin) { 
    mwArray varargout(mwArray::UNDEFINED); 
    varargout = Miofun_private_bitslice(0, varargin.ToArray()); 
} 
 
// 
// The function "mlxIofun_private_bitslice" contains the feval interface for 
// the "iofun/private/bitslice" M-function from file 
// "D:\matlab\matlab\toolbox\matlab\iofun\private\bitslice.dll" (lines 0-0). 
// The feval function calls the implementation version of 
// iofun/private/bitslice through this function. This function processes any 
// input arguments and passes them to the implementation version of the 
// function, appearing above. 
// 
void mlxIofun_private_bitslice(int nlhs, 
                               mxArray * plhs[], 
                               int nrhs, 
                               mxArray * prhs[]) { 
    MW_BEGIN_MLX(); 
    { 
        mwArray mprhs[1]; 
        mwArray mplhs[1]; 
        mclCppUninitializeArrays(1, mplhs); 
        mprhs[0] = mclCreateVararginCell(nrhs, prhs); 
        mplhs[0] = Miofun_private_bitslice(nlhs, mprhs[0]); 
        mclAssignVarargoutCell(0, nlhs, plhs, mplhs[0].FreezeData()); 
    } 
    MW_END_MLX(); 
} 
 
// 
// The function "Miofun_private_bitslice" is the implementation version of the 
// "iofun/private/bitslice" M-function from file 
// "D:\matlab\matlab\toolbox\matlab\iofun\private\bitslice.dll" (lines 1-1). It 
// contains the actual compiled code for that M-function. It is a static 
// function and must only be called from one of the interface functions, 
// appearing below. 
// 
static mwArray Miofun_private_bitslice(int nargout_, mwArray varargin) { 
    mwLocalFunctionTable save_local_function_table_ 
      (&_local_function_table_iofun_private_bitslice); 
    return mclCppExecMexFile("iofun/private/bitslice", nargout_, varargin); 
}