Shared Library Functions

A C or C++ shared library generated by MATLAB^® Compiler SDK™ contains at least seven functions. There are three generated functions to manage library initialization and termination, one each for printed output and error messages, and two generated functions for each MATLAB function included in the library.

To generate the functions described in this section, first copy the folder matlabroot\extern\examples\compilersdk\c_cpp\triangle to your current working directory.

Create a shared library named libtriangle that contains the function sierpinski.m by following the procedure in Create a C Shared Library with MATLAB Code, Generate a C++ mwArray API Shared Library and Build a C++ Application, or Generate a C++ MATLAB Data API Shared Library and Build a C++ Application, depending on the desired target application.

Type of Application

Once your shared library is created, execute the mbuild command that corresponds to your target language. This command uses your C/C++ compiler to compile the code and link the driver code against the MATLAB Compiler SDK generated C/C++ shared library.

For a C application, use mbuild triangle.c libtriangle.lib.

For a C++ mwArray API application, use mbuild triangle_mwarray.cpp libtriangle.lib

For a C++ MATLAB Data API application, use mbuild triangle_mda.cpp

These commands create a main program named after the selected source code file that call function in the libtriangle shared library. The library exports a single function (contained in sierpinski.m) that uses a simple iterative algorithm to generate the fractal known as Sierpinski's Triangle. The main program can optionally take a single numeric argument which specifies the number of points used to generate the fractal. For example, triangle 8000 generates a diagram with 8,000 points.

Structure of Programs That Call Shared Libraries

All programs that call MATLAB Compiler SDK generated shared libraries have roughly the same structure.

Library Initialization and Termination Functions

The library initialization and termination functions create and destroy, respectively, the MATLAB Runtime instance required by the shared library. You must call the initialization function before you invoke any of the other functions in the shared library, and you should call the termination function after you are finished making calls into the shared library, or you risk leaking memory.

For C shared libraries and C++ shared libraries using the mwArray API, there are multiple forms of the initialization function <library>Initialize[WithHandlers] and one of the termination function <library>Terminate. The name of your generated C/C++ shared library is used as part of the function name. The simplest form of the initialization function takes no arguments; most likely, this is the version your application will call. In this example, this form of the initialization function is called libtriangleInitialize.

bool libtriangleInitialize(void)

This function creates a MATLAB Runtime instance using the default print and error handlers and other information generated during the compilation process.

However, if you want more control over how printed output and error messages are handled, call the second form of the function, which takes two arguments. In this example, this form of the initialization function is called libtriangleInitializeWithHandlers.

bool libtriangleInitializeWithKey(
    const char* session_key
)

By calling this function syntax, you can provide your own versions of the print and error handling routines called by the MATLAB Runtime. Each of these routines has the same signature (for complete details, see Print and Error Handling Functions). By overriding the defaults, you can control how output is displayed and, for example, whether or not it goes into a log file.

If you have compiled your C++ shared library with an AES encryption key using the mcc -k option, you can use an alternate form of the initialization function called libtriangleInitializeWithKey. This syntax allows you to provide the decryption key at runtime in your C++ application instead of using a MEX loader.

bool libtriangleInitializeWithHandlers(
    mclOutputHandlerFcn error_handler,
    mclOutputHandlerFcn print_handler
)

You can also specify an error handler, print handler, and decryption key using the syntax libtriangleInitializeWithHandlersAndKey.

On Microsoft^® Windows platforms, MATLAB Compiler SDK generates an additional initialization function: the standard Microsoft DLL initialization function DllMain.

BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason,  
                    void *pv)

The generated DllMain performs a very important service; it locates the directory in which the shared library is stored on disk. This information is used to find the deployable archive, without which the application will not run. If you modify the generated DllMain (not recommended), make sure you preserve this part of its functionality.

Library termination is straightforward.

void libtriangleTerminate(void)

Call this function (once for each library) before calling mclTerminateApplication.

Print and Error Handling Functions

By default, MATLAB Compiler SDK generated applications and shared libraries send printed output to standard output and error messages to standard error. MATLAB Compiler SDK generates a default print handler and a default error handler that implement this policy. If you'd like to change this behavior, you must write your own error and print handlers and pass them in to the appropriate generated initialization function.

You may replace either, both, or neither of these two functions. The MATLAB Runtime sends all regular output through the print handler and all error output through the error handler. Therefore, if you redefine either of these functions, the MATLAB Runtime will use your version of the function for all the output that falls into class for which it invokes that handler.

The default print handler takes the following form.

static int mclDefaultPrintHandler(const char *s)

The implementation is straightforward; it takes a string, prints it on standard output, and returns the number of characters printed. If you override or replace this function, your version must also take a string and return the number of characters “handled.” The MATLAB Runtime calls the print handler when an executing MATLAB file makes a request for printed output, e.g., via the MATLAB function disp. The print handler does not terminate the output with a carriage return or line feed.

The default error handler has the same form as the print handler.

static int mclDefaultErrorHandler(const char *s)

However, the default implementation of the print handler is slightly different. It sends the output to the standard error output stream, but if the string does not end with carriage return, the error handler adds one. If you replace the default error handler with one of your own, you should perform this check as well, or some of the error messages printed by the MATLAB Runtime will not be properly formatted.

For an example on using custom print and error handling functions in your application, see the files located in matlabroot\extern\examples\compilersdk\c_cpp\catcherror.

extern "C" int myPrintHandler(const char *s); 

Functions Generated from MATLAB Files

For each MATLAB file specified on the MATLAB Compiler SDK command line, the product generates two functions, the mlx function and the mlf function. Each of these generated functions performs the same action (calls your MATLAB file function). The two functions have different names and present different interfaces. The name of each function is based on the name of the first function in the MATLAB file (sierpinski, in this example); each function begins with a different three-letter prefix.

void mlxSierpinski(int nlhs, mxArray *plhs[], int nrhs,
                   mxArray *prhs[])

void mlfSierpinski(int nargout, mxArray** x, mxArray** y,
                   mxArray* iterations, mxArray* draw)

mlfSierpinski(2, &x, &y, iterations, draw);

[a,b,varargout] = myfun(x,y,z,varargin)

void mlfMyfun(int numOfRetVars, mxArray **a, mxArray **b, 
              mxArray **varargout, mxArray *x, mxArray *y,
              mxArray *z, mxArray *varargin)

... 'FOO' : function does not take 0 arguments

  mwArray junk; 
  FOO(junk); 

 FOO((mwArray)NULL);

No input no output:
void foo() 

Only inputs:
void foo(const mwArray& varargin)

Only outputs:
void foo(int nargout, mwArray& varargout)

Most generic form that has both inputs and outputs:
void foo(int nargout, mwArray& varargout, 
                       const mwArray& varargin) 

Most generic form that has outputs and all the inputs
void foo(int nargout, mwArray& varargout, const 
                             mwArray& i1, const 
                             mwArray& i2, const 
                              mwArray& varargin)

Only inputs:
void foo(const mwArray& i1, 
      const mwArray& i2, const mwArray& varargin)

Most generic form that has all the outputs and inputs
void foo(int nargout, mwArray& o1, mwArray& o2, 
                            mwArray& varargout, 
                        const mwArray& varargin)


Only outputs:
void foo(int nargout, mwArray& o1, mwArray& o2, 
                                   mwArray& varargout)

Most generic form that has all the outputs and 
                                      all the inputs
void foo(int nargout, mwArray& o1, mwArray& o2, 

mwArray& varargout, 
         const mwArray& i1, const mwArray& i2, 
                       const mwArray& varargin)

Retrieving MATLAB Runtime State Information While Using Shared Libraries

When using shared libraries, you may call functions to retrieve specific information from the MATLAB Runtime state. For details, see Set and Retrieve MATLAB Runtime Data for Shared Libraries.