1540 lines
45 KiB
C++
1540 lines
45 KiB
C++
/*
|
|
* PUBLISHed header for libmclmcr, the mclmcr library.
|
|
*
|
|
* Copyright 1984-2020 The MathWorks, Inc.
|
|
*/
|
|
|
|
#if defined(_MSC_VER)
|
|
# pragma once
|
|
#endif
|
|
#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3))
|
|
# pragma once
|
|
#endif
|
|
|
|
#ifndef mclmcr_published_api_hpp
|
|
#define mclmcr_published_api_hpp
|
|
|
|
|
|
#ifndef LIBMWMCLMCR_API_EXTERN_C
|
|
# ifdef __cplusplus
|
|
# define LIBMWMCLMCR_API_EXTERN_C extern "C"
|
|
# else
|
|
# define LIBMWMCLMCR_API_EXTERN_C extern
|
|
# endif
|
|
#endif
|
|
|
|
#ifndef LIBMWMCLMCR_API
|
|
# define LIBMWMCLMCR_API
|
|
#endif
|
|
|
|
#ifndef LIBMWMCLMCR_API_LIBMWMCLMCR_API_EXTERN_C
|
|
# define LIBMWMCLMCR_API_LIBMWMCLMCR_API_EXTERN_C LIBMWMCLMCR_API_EXTERN_C LIBMWMCLMCR_API
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
typedef int (*mclReadCtfStreamFcn)(char* s, int n);
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* All the types of components we can generate code for. These values
|
|
* determine how the component initializes itself.
|
|
*/
|
|
typedef enum
|
|
{
|
|
NoObjectType,
|
|
COMObject,
|
|
JavaObject,
|
|
DotNetObject
|
|
} mccComponentType;
|
|
|
|
typedef enum
|
|
{
|
|
ExeTarget,
|
|
LibTarget,
|
|
MexTarget,
|
|
SfunTarget,
|
|
AnyTarget
|
|
} mccTargetType;
|
|
|
|
|
|
typedef struct mclCtfStream_tag
|
|
{
|
|
/*This field is only here to prevent an
|
|
empty struct warning for some compilers. */
|
|
char unused;
|
|
} mclCtfStream_tag;
|
|
|
|
typedef mclCtfStream_tag* mclCtfStream;
|
|
#include <stddef.h>
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mclCtfStream mclGetStreamFromArraySrc(char *buffer, int bufferSize);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void mclDestroyStream(mclCtfStream pStream);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mclCtfStream mclGetEmbeddedCtfStream(void* handle);
|
|
|
|
|
|
#include "mclbase.h" /*for mclOutputHandler MCRInstanceProxy*/
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclInitializeComponentInstanceNonEmbeddedStandalone(HMCRINSTANCE* inst,
|
|
const char* path_to_component,
|
|
const char* component_name,
|
|
mccTargetType ttype,
|
|
mclOutputHandlerFcn error_handler,
|
|
mclOutputHandlerFcn print_handler);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclInitializeInstanceWithoutComponent(HMCRINSTANCE* inst,
|
|
const char** options,
|
|
size_t count,
|
|
mclOutputHandlerFcn error_handler,
|
|
mclOutputHandlerFcn print_handler);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclInitializeComponentInstanceCtfFileToCache(HMCRINSTANCE* inst,
|
|
mclOutputHandlerFcn error_handler,
|
|
mclOutputHandlerFcn print_handler,
|
|
const char* ctfFileLocation);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclInitializeComponentInstanceEmbedded(HMCRINSTANCE* inst,
|
|
mclOutputHandlerFcn error_handler,
|
|
mclOutputHandlerFcn print_handler,
|
|
mclCtfStream ctfStream);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclInitializeComponentInstanceWithCallbk(HMCRINSTANCE* inst,
|
|
mclOutputHandlerFcn error_handler,
|
|
mclOutputHandlerFcn print_handler,
|
|
mclReadCtfStreamFcn readCtfStream_handler,
|
|
size_t ctfStreamSize);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclInitializeComponentInstanceFromExtractedComponent(HMCRINSTANCE* inst,
|
|
mclOutputHandlerFcn error_handler,
|
|
mclOutputHandlerFcn print_handler,
|
|
const char* component_id);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclInitializeComponentInstanceFromExtractedLocation(HMCRINSTANCE* inst,
|
|
mclOutputHandlerFcn error_handler,
|
|
mclOutputHandlerFcn print_handler,
|
|
const char* extractedLoc);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetDotNetComponentType(void);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetMCCTargetType(bool isLibrary);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C const char * getStandaloneFileName(const char* path_to_ctf, const char* component_name);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclStandaloneGenericMain(size_t argc,
|
|
const char ** argv,
|
|
const char* ctfFileName,
|
|
bool ExtractToComponentCache,
|
|
void* ctfSettings);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclStandaloneCtfxMain(size_t argc,
|
|
const char** argv);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void mclWaitForFiguresToDie(HMCRINSTANCE inst);
|
|
|
|
|
|
#include "matrix.h"
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
/* Forward declarations */
|
|
class ref_count_obj;
|
|
class char_buffer;
|
|
class array_ref;
|
|
class array_buffer;
|
|
class error_info;
|
|
|
|
/* Class declarations */
|
|
|
|
class ref_count_obj
|
|
{
|
|
public:
|
|
/* Virtual destructor required to avoid compiler warnings. */
|
|
virtual ~ref_count_obj() {}
|
|
virtual int addref() = 0;
|
|
virtual int release() = 0;
|
|
};
|
|
|
|
class char_buffer: public ref_count_obj
|
|
{
|
|
public:
|
|
/* Virtual destructor required to avoid compiler warnings. */
|
|
virtual ~char_buffer() {}
|
|
virtual size_t size() = 0;
|
|
virtual const char* get_buffer() = 0;
|
|
virtual int set_buffer(const char* str) = 0;
|
|
virtual int compare_to(char_buffer* p) = 0;
|
|
};
|
|
|
|
class array_ref: public ref_count_obj
|
|
{
|
|
public:
|
|
/* Virtual destructor required to avoid compiler warnings. */
|
|
virtual ~array_ref() {}
|
|
virtual mxClassID classID() = 0;
|
|
virtual array_ref* deep_copy() = 0;
|
|
virtual void detach() = 0;
|
|
virtual array_ref* shared_copy() = 0;
|
|
virtual array_ref* serialize() = 0;
|
|
virtual size_t element_size() = 0;
|
|
virtual mwSize number_of_elements() = 0;
|
|
virtual mwSize number_of_nonzeros() = 0;
|
|
virtual mwSize maximum_nonzeros() = 0;
|
|
virtual mwSize number_of_dimensions() = 0;
|
|
virtual array_ref* get_dimensions() = 0;
|
|
virtual int number_of_fields() = 0;
|
|
virtual char_buffer* get_field_name(int i) = 0;
|
|
virtual bool is_empty() = 0;
|
|
virtual bool is_sparse() = 0;
|
|
virtual bool is_numeric() = 0;
|
|
virtual bool is_complex() = 0;
|
|
virtual bool is_string() = 0;
|
|
virtual bool is_missing_element(mwSize index) = 0;
|
|
virtual int make_complex() = 0;
|
|
virtual bool equals(array_ref* p) = 0;
|
|
virtual int compare_to(array_ref* p) = 0;
|
|
virtual int hash_code() = 0;
|
|
virtual char_buffer* to_string() = 0;
|
|
virtual array_ref* row_index() = 0;
|
|
virtual array_ref* column_index() = 0;
|
|
virtual array_ref* get(mwSize num_indices, const mwIndex* index) = 0;
|
|
virtual array_ref* get(const char* name, mwSize num_indices, const mwIndex* index) = 0;
|
|
virtual array_ref* getV(mwSize num_indices, va_list vargs) = 0;
|
|
virtual array_ref* getV(const char* name, mwSize num_indices, va_list vargs) = 0;
|
|
virtual int set(array_ref* p) = 0;
|
|
virtual array_ref* real() = 0;
|
|
virtual array_ref* imag() = 0;
|
|
/* Virtual member functions can't be templated. Thus, we need to declare all the ones we need. */
|
|
virtual int get_numeric(mxDouble* x, mwSize len) = 0;
|
|
virtual int get_numeric(mxSingle* x, mwSize len) = 0;
|
|
virtual int get_numeric(mxInt8* x, mwSize len) = 0;
|
|
virtual int get_numeric(mxUint8* x, mwSize len) = 0;
|
|
virtual int get_numeric(mxInt16* x, mwSize len) = 0;
|
|
virtual int get_numeric(mxUint16* x, mwSize len) = 0;
|
|
virtual int get_numeric(mxInt32* x, mwSize len) = 0;
|
|
virtual int get_numeric(mxUint32* x, mwSize len) = 0;
|
|
virtual int get_numeric(mxInt64* x, mwSize len) = 0;
|
|
virtual int get_numeric(mxUint64* x, mwSize len) = 0;
|
|
virtual int get_char(mxChar* x, mwSize len) = 0;
|
|
virtual int get_logical(mxLogical* x, mwSize len) = 0;
|
|
virtual int get_string_element(mwSize index, const mxChar** str, mwSize* len) = 0;
|
|
virtual int get_string_data(const mxChar** data, mwSize* array_size, mwSize *data_size) = 0;
|
|
virtual int set_numeric(const mxDouble* x, mwSize len) = 0;
|
|
virtual int set_numeric(const mxSingle* x, mwSize len) = 0;
|
|
virtual int set_numeric(const mxInt8* x, mwSize len) = 0;
|
|
virtual int set_numeric(const mxUint8* x, mwSize len) = 0;
|
|
virtual int set_numeric(const mxInt16* x, mwSize len) = 0;
|
|
virtual int set_numeric(const mxUint16* x, mwSize len) = 0;
|
|
virtual int set_numeric(const mxInt32* x, mwSize len) = 0;
|
|
virtual int set_numeric(const mxUint32* x, mwSize len) = 0;
|
|
virtual int set_numeric(const mxInt64* x, mwSize len) = 0;
|
|
virtual int set_numeric(const mxUint64* x, mwSize len) = 0;
|
|
virtual int set_char(const mxChar* x, mwSize len) = 0;
|
|
virtual int set_logical(const mxLogical* x, mwSize len) = 0;
|
|
virtual int set_string_element(mwSize index, const mxChar* x) = 0;
|
|
virtual int set_string_data(const mxChar** x, mwSize array_size) = 0;
|
|
};
|
|
|
|
class array_buffer: public ref_count_obj
|
|
{
|
|
public:
|
|
/* Virtual destructor required to avoid compiler warnings. */
|
|
virtual ~array_buffer() {}
|
|
virtual mwSize size() = 0;
|
|
virtual array_ref* get(mwIndex offset) = 0;
|
|
virtual int set(mwIndex offset, array_ref* p) = 0;
|
|
virtual int add(array_ref* pa) = 0;
|
|
virtual int remove(mwIndex offset) = 0;
|
|
virtual int clear() = 0;
|
|
virtual array_ref* to_cell(mwIndex offset, mwSize len) = 0;
|
|
};
|
|
|
|
class error_info: public ref_count_obj
|
|
{
|
|
public:
|
|
/* Virtual destructor required to avoid compiler warnings. */
|
|
virtual ~error_info() {}
|
|
virtual const char* get_message() = 0;
|
|
virtual size_t get_stack_trace(char*** stack) = 0;
|
|
};
|
|
|
|
#endif /* #ifdef __cplusplus */
|
|
|
|
|
|
#include "matrix.h"
|
|
|
|
|
|
#ifdef __cplusplus
|
|
/* This is an extern "C" API exclusively for use by C++ programs. It
|
|
* exists solely to work around binary incompatibilities between different
|
|
* C++ compilers. For example, a Borland C++ program cannot invoke a method
|
|
* on an array_ref object created by a library compiled with Microsoft Visual
|
|
* C++. The mwArray API, therefore, invokes array_ref methods indirectly, by
|
|
* passing the array_ref object to one of these extern "C" routines, which
|
|
* are implemented in the MCLMCR module. Since this module is part of the
|
|
* MCR, it can invoke array_ref methods with impunity.
|
|
*
|
|
* This API needs to be protected by #ifdef __cplusplus because some of the
|
|
* input arguments to the functions it contains are pointers to objects.
|
|
* Translating all of these to void *'s is overly complex and unnecessary,
|
|
* as this API is always going to be called from a C++ program.
|
|
*/
|
|
|
|
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int ref_count_obj_addref(ref_count_obj *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int ref_count_obj_release(ref_count_obj *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C size_t char_buffer_size(char_buffer *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C const char* char_buffer_get_buffer(char_buffer *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int char_buffer_set_buffer(char_buffer *obj, const char* str);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int char_buffer_compare_to(char_buffer *obj, char_buffer* p);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mxClassID array_ref_classID(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_deep_copy(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void array_ref_detach(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_shared_copy(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_serialize(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C size_t array_ref_element_size(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mwSize array_ref_number_of_elements(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mwSize array_ref_number_of_nonzeros(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mwSize array_ref_maximum_nonzeros(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mwSize array_ref_number_of_dimensions(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_get_dimensions(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_number_of_fields(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C char_buffer* array_ref_get_field_name(array_ref *obj, int i);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_ref_is_empty(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_ref_is_sparse(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_ref_is_numeric(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_ref_is_complex(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_ref_is_matlab_string(array_ref* obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_ref_is_missing_string_element(array_ref* obj, mwSize index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_make_complex(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_ref_equals(array_ref *obj, array_ref* p);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_compare_to(array_ref *obj, array_ref* p);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_hash_code(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C char_buffer* array_ref_to_string(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_row_index(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_column_index(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_get_int(array_ref *obj, mwSize num_indices, const mwIndex* index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_get_const_char(array_ref *obj, const char* name, mwSize num_indices, const mwIndex* index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_getV_int(array_ref *obj, mwSize num_indices, va_list vargs);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_getV_const_char(array_ref *obj, const char* name, mwSize num_indices, va_list vargs);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set(array_ref *obj, array_ref* p);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_real(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_ref_imag(array_ref *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_numeric_mxDouble(array_ref *obj, mxDouble* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_numeric_mxSingle(array_ref *obj, mxSingle* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_numeric_mxInt8(array_ref *obj, mxInt8* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_numeric_mxUint8(array_ref *obj, mxUint8* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_numeric_mxInt16(array_ref *obj, mxInt16* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_numeric_mxUint16(array_ref *obj, mxUint16* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_numeric_mxInt32(array_ref *obj, mxInt32* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_numeric_mxUint32(array_ref *obj, mxUint32* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_numeric_mxInt64(array_ref *obj, mxInt64* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_numeric_mxUint64(array_ref *obj, mxUint64* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_char(array_ref *obj, mxChar* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_string_element(array_ref *obj, mwSize index, const mxChar** str, mwSize* len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_matlab_string(array_ref *obj, const mxChar** data, mwSize* array_size, mwSize *data_size);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_get_logical(array_ref *obj, mxLogical* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_numeric_mxDouble(array_ref *obj, const mxDouble* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_numeric_mxSingle(array_ref *obj, const mxSingle* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_numeric_mxInt8(array_ref *obj, const mxInt8* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_numeric_mxUint8(array_ref *obj, const mxUint8* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_numeric_mxInt16(array_ref *obj, const mxInt16* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_numeric_mxUint16(array_ref *obj, const mxUint16* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_numeric_mxInt32(array_ref *obj, const mxInt32* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_numeric_mxUint32(array_ref *obj, const mxUint32* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_numeric_mxInt64(array_ref *obj, const mxInt64* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_numeric_mxUint64(array_ref *obj, const mxUint64* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_char(array_ref *obj, const mxChar* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_string_element(array_ref* obj, mwSize index, const mxChar* x);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_matlab_string(array_ref* obj, const mxChar** x, mwSize array_size);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_ref_set_logical(array_ref *obj, const mxLogical* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mwSize array_buffer_size(array_buffer *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_buffer_get(array_buffer *obj, mwIndex offset);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_buffer_set(array_buffer *obj, mwIndex offset, array_ref* p);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_buffer_add(array_buffer *obj, array_ref* pa);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_buffer_remove(array_buffer *obj, mwIndex offset);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_buffer_clear(array_buffer *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_ref* array_buffer_to_cell(array_buffer *obj, mwIndex offset, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C const char* error_info_get_message(error_info *obj);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C size_t error_info_get_stack_trace(error_info *obj, char*** stack);
|
|
|
|
|
|
#endif /* #ifdef __cplusplus */
|
|
|
|
|
|
#define MCLCPP_OK 0
|
|
#define MCLCPP_ERR -1
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclcppGetLastError(void** ppv);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclcppCreateError(void** ppv, const char* msg);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void mclcppSetLastError(const char* msg);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclcppErrorCheck(void);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C const char* mclcppGetLastErrorMessage(void);
|
|
|
|
#ifdef __cplusplus
|
|
|
|
#include <iostream>
|
|
#include <exception>
|
|
|
|
class mwException : public std::exception
|
|
{
|
|
public:
|
|
mwException() : std::exception()
|
|
{
|
|
m_err = 0;
|
|
mclcppCreateError((void**)&m_err, "Unspecified error");
|
|
}
|
|
mwException(const char* msg) : std::exception()
|
|
{
|
|
m_err = 0;
|
|
mclcppCreateError((void**)&m_err, (msg ? msg : "Unspecified error"));
|
|
}
|
|
mwException(const mwException& e) : std::exception()
|
|
{
|
|
m_err = e.m_err;
|
|
if (m_err) {
|
|
ref_count_obj_addref(m_err);
|
|
}
|
|
}
|
|
mwException(error_info* pe)
|
|
{
|
|
m_err = 0;
|
|
if (pe) {
|
|
m_err = pe;
|
|
ref_count_obj_addref(m_err);
|
|
} else {
|
|
mclcppCreateError((void**)&m_err, "Unspecified error");
|
|
}
|
|
}
|
|
mwException(error_info* pe, bool bAddRef)
|
|
{
|
|
m_err = 0;
|
|
if (pe) {
|
|
m_err = pe;
|
|
if (bAddRef) {
|
|
ref_count_obj_addref(m_err);
|
|
}
|
|
} else {
|
|
mclcppCreateError((void**)&m_err, "Unspecified error");
|
|
}
|
|
}
|
|
mwException(const std::exception& e) : std::exception()
|
|
{
|
|
m_err = 0;
|
|
mclcppCreateError((void**)&m_err, e.what());
|
|
}
|
|
virtual ~mwException() throw()
|
|
{
|
|
if (m_err) {
|
|
ref_count_obj_release(m_err);
|
|
}
|
|
}
|
|
mwException& operator=(const std::exception& e)
|
|
{
|
|
if (m_err) {
|
|
ref_count_obj_release(m_err);
|
|
}
|
|
mclcppCreateError((void**)&m_err, e.what());
|
|
return *this;
|
|
}
|
|
mwException& operator=(const mwException& e)
|
|
{
|
|
if (m_err) {
|
|
ref_count_obj_release(m_err);
|
|
}
|
|
m_err = e.m_err;
|
|
if (m_err) {
|
|
ref_count_obj_addref(m_err);
|
|
}
|
|
return *this;
|
|
}
|
|
const char *what() const throw()
|
|
{
|
|
return (m_err ? error_info_get_message(m_err) : NULL);
|
|
}
|
|
static void raise_error()
|
|
{
|
|
error_info* pe = 0;
|
|
if (mclcppGetLastError((void**)&pe) == MCLCPP_ERR) {
|
|
throw mwException();
|
|
}
|
|
throw mwException(pe, false);
|
|
}
|
|
void print_stack_trace()
|
|
{
|
|
char** stack;
|
|
size_t stackDepth;
|
|
|
|
stackDepth = get_stack_trace(&stack);
|
|
if (stackDepth > 0) {
|
|
std::cerr << "... Matlab M-code Stack Trace ..." << std::endl;
|
|
for (size_t i=0; i<stackDepth; i++) {
|
|
std::cerr << stack[i] << std::endl;
|
|
}
|
|
}
|
|
}
|
|
static void check_raise_error()
|
|
{
|
|
if (!mclcppErrorCheck()) {
|
|
return;
|
|
}
|
|
mwException::raise_error();
|
|
}
|
|
protected:
|
|
error_info* m_err;
|
|
|
|
private:
|
|
size_t get_stack_trace(char*** stack)
|
|
{
|
|
return (m_err ? error_info_get_stack_trace(m_err, stack) : 0);
|
|
}
|
|
};
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
template<typename T>
|
|
class mw_auto_ptr_t
|
|
{
|
|
public:
|
|
mw_auto_ptr_t()
|
|
{
|
|
m_p = 0;
|
|
}
|
|
explicit mw_auto_ptr_t(T* p)
|
|
{
|
|
m_p = p;
|
|
addref();
|
|
}
|
|
mw_auto_ptr_t(T*p, bool bAddRef)
|
|
{
|
|
m_p = p;
|
|
if (bAddRef) {
|
|
addref();
|
|
}
|
|
}
|
|
virtual ~mw_auto_ptr_t()
|
|
{
|
|
if (m_p) {
|
|
ref_count_obj_release(m_p);
|
|
}
|
|
}
|
|
void addref()
|
|
{
|
|
if (m_p) {
|
|
ref_count_obj_addref(m_p);
|
|
}
|
|
}
|
|
void release()
|
|
{
|
|
if (m_p) {
|
|
ref_count_obj_release(m_p);
|
|
m_p = 0;
|
|
}
|
|
}
|
|
void attach(T* p, bool bAddRef)
|
|
{
|
|
release();
|
|
m_p = p;
|
|
if (bAddRef) {
|
|
addref();
|
|
}
|
|
}
|
|
T* detach()
|
|
{
|
|
T* p = m_p;
|
|
m_p = 0;
|
|
return p;
|
|
}
|
|
T* operator->(void) const
|
|
{
|
|
if (!m_p) {
|
|
throw mwException("Null pointer");
|
|
}
|
|
return m_p;
|
|
}
|
|
T** operator&(void)
|
|
{
|
|
release();
|
|
return &m_p;
|
|
}
|
|
operator T*() const
|
|
{
|
|
return m_p;
|
|
}
|
|
mw_auto_ptr_t<T>& operator=(T* p)
|
|
{
|
|
release();
|
|
m_p = p;
|
|
addref();
|
|
return *this;
|
|
}
|
|
mw_auto_ptr_t<T>& operator=(const mw_auto_ptr_t<T>& ptr)
|
|
{
|
|
release();
|
|
m_p = ptr.m_p;
|
|
addref();
|
|
return *this;
|
|
}
|
|
bool operator!() const
|
|
{
|
|
return (m_p == 0);
|
|
}
|
|
operator bool() const
|
|
{
|
|
return (m_p != 0);
|
|
}
|
|
bool operator==(const mw_auto_ptr_t<T>& ptr)
|
|
{
|
|
return (m_p == (T*)ptr);
|
|
}
|
|
bool operator!=(const mw_auto_ptr_t<T>& ptr)
|
|
{
|
|
return (m_p != (T*)ptr);
|
|
}
|
|
protected:
|
|
T* m_p;
|
|
};
|
|
|
|
#endif /* ifdef __cplusplus */
|
|
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclCreateCharBuffer(void** ppv, const char* str);
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
//#include <iostream>
|
|
|
|
|
|
class mwString
|
|
{
|
|
public:
|
|
mwString()
|
|
{
|
|
if (mclCreateCharBuffer((void**)&m_str, "") == MCLCPP_ERR) {
|
|
mwException::raise_error();
|
|
}
|
|
}
|
|
mwString(const char* str)
|
|
{
|
|
if (mclCreateCharBuffer((void**)&m_str, str) == MCLCPP_ERR) {
|
|
mwException::raise_error();
|
|
}
|
|
}
|
|
mwString(char_buffer* buff, bool bAddref)
|
|
{
|
|
m_str.attach(buff, bAddref);
|
|
}
|
|
mwString(const mwString& str)
|
|
{
|
|
if (mclCreateCharBuffer((void**)&m_str, str) == MCLCPP_ERR) {
|
|
mwException::raise_error();
|
|
}
|
|
if (char_buffer_set_buffer(m_str, (const char*)str) == MCLCPP_ERR) {
|
|
mwException::raise_error();
|
|
}
|
|
}
|
|
virtual ~mwString() {}
|
|
public:
|
|
mwSize Length() const
|
|
{
|
|
return char_buffer_size(m_str);
|
|
}
|
|
operator const char* () const
|
|
{
|
|
return char_buffer_get_buffer(m_str);
|
|
}
|
|
mwString& operator=(const mwString& str)
|
|
{
|
|
if (&str == this) {
|
|
return *this;
|
|
}
|
|
if (char_buffer_set_buffer(m_str, (const char*)str) == MCLCPP_ERR) {
|
|
mwException::raise_error();
|
|
}
|
|
return *this;
|
|
}
|
|
mwString& operator=(const char* str)
|
|
{
|
|
if (char_buffer_set_buffer(m_str, str) == MCLCPP_ERR) {
|
|
mwException::raise_error();
|
|
}
|
|
return *this;
|
|
}
|
|
bool operator==(const mwString& str) const
|
|
{
|
|
return (char_buffer_compare_to(m_str, str.m_str) == 0);
|
|
}
|
|
bool operator!=(const mwString& str) const
|
|
{
|
|
return (char_buffer_compare_to(m_str, str.m_str) != 0);
|
|
}
|
|
bool operator<(const mwString& str) const
|
|
{
|
|
return (char_buffer_compare_to(m_str, str.m_str) < 0);
|
|
}
|
|
bool operator<=(const mwString& str) const
|
|
{
|
|
return (char_buffer_compare_to(m_str, str.m_str) <= 0);
|
|
}
|
|
bool operator>(const mwString& str) const
|
|
{
|
|
return (char_buffer_compare_to(m_str, str.m_str) > 0);
|
|
}
|
|
bool operator>=(const mwString& str) const
|
|
{
|
|
return (char_buffer_compare_to(m_str, str.m_str) >= 0);
|
|
}
|
|
friend std::ostream& operator<<(std::ostream& os, const mwString& str)
|
|
{
|
|
os << (const char*)str;
|
|
return os;
|
|
}
|
|
private:
|
|
mw_auto_ptr_t<char_buffer> m_str;
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C double mclGetEps(void);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C double mclGetInf(void);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C double mclGetNaN(void);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclIsFinite(double x);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclIsInf(double x);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclIsNaN(double x);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclIsIdentical(mxArray* pArray1, mxArray* pArray2);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetEmptyArray(void** ppv, mxClassID classid);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetMatrix(void** ppv, mwSize num_rows, mwSize num_cols, mxClassID classid, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetArray(void** ppv, mwSize num_dims, const mwSize* dims, mxClassID classid, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetNumericMatrix(void** ppv, mwSize num_rows, mwSize num_cols, mxClassID mxID, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetNumericArray(void** ppv, mwSize num_dims, const mwSize* dims, mxClassID mxID, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarDouble(void** ppv, mxDouble re, mxDouble im, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarSingle(void** ppv, mxSingle re, mxSingle im, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarInt8(void** ppv, mxInt8 re, mxInt8 im, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarUint8(void** ppv, mxUint8 re, mxUint8 im, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarInt16(void** ppv, mxInt16 re, mxInt16 im, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarUint16(void** ppv, mxUint16 re, mxUint16 im, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarInt32(void** ppv, mxInt32 re, mxInt32 im, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarUint32(void** ppv, mxUint32 re, mxUint32 im, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarInt64(void** ppv, mxInt64 re, mxInt64 im, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarUint64(void** ppv, mxUint64 re, mxUint64 im, mxComplexity cmplx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetCharMatrix(void** ppv, mwSize num_rows, mwSize num_cols);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetCharArray(void** ppv, mwSize num_dims, const mwSize* dims);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarChar(void** ppv, mxChar x);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetString(void** ppv, const char* str);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetCharMatrixFromStrings(void** ppv, mwSize m, const char** str);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclIsMatlabString(const mxArray* pa);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclIsMissingStringElement(const mxArray* pa, mwSize index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mxArray* mclCreateMatlabString(mwSize m, const mxChar** strs);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mxArray *mclCreateMatlabStringArray(mwSize m, const mwSize* dims);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMatlabStringGetElement(const mxArray* src, mwSize index, const mxChar** str, mwSize* len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMatlabStringSetElement(mxArray* src, mwSize index, const mxChar* str);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMatlabStringGetData(const mxArray* src, const mxChar** data, mwSize* array_size, mwSize *data_size);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMatlabStringSetData(mxArray* src, const mxChar** data, mwSize array_size);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMatlabStringGetNumberOfDimensions(const mxArray* src, mwSize* num_dims);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMatlabStringGetDimensions(const mxArray* src, const mwSize** dims);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMatlabStringGetNumberOfElements(const mxArray* src, mwSize* num_elms);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetMatlabString(void** ppv, mwSize m, const mxChar** strs);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetMatlabStringArray(void** ppv, mwSize m, const mwSize* dims);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetLogicalMatrix(void** ppv, mwSize num_rows, mwSize num_cols);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetLogicalArray(void** ppv, mwSize num_dims, const mwSize* dims);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetScalarLogical(void** ppv, mxLogical x);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetCellMatrix(void** ppv, mwSize num_rows, mwSize num_cols);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetCellArray(void** ppv, mwSize num_dims, const mwSize* dims);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetStructMatrix(void** ppv, mwSize num_rows, mwSize num_cols, int nFields, const char** fieldnames);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetStructArray(void** ppv, mwSize num_dims, const mwSize* dims, int nFields, const char** fieldnames);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetNumericSparse(
|
|
void** ppv,
|
|
mwSize rowindex_size,
|
|
const mwSize* rowindex,
|
|
mwSize colindex_size,
|
|
const mwSize* colindex,
|
|
mwSize data_size,
|
|
const void* rData,
|
|
const void* iData,
|
|
mwSize num_rows,
|
|
mwSize num_cols,
|
|
mwSize nzmax,
|
|
mxClassID mxType,
|
|
mxComplexity cmplx
|
|
);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetNumericSparseInferRowsCols(
|
|
void** ppv,
|
|
mwSize rowindex_size,
|
|
const mwSize* rowindex,
|
|
mwSize colindex_size,
|
|
const mwSize* colindex,
|
|
mwSize data_size,
|
|
const void* rData,
|
|
const void* iData,
|
|
mwSize nzmax,
|
|
mxClassID mxType,
|
|
mxComplexity cmplx
|
|
);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetLogicalSparse(
|
|
void** ppv,
|
|
mwSize rowindex_size,
|
|
const mwIndex* rowindex,
|
|
mwSize colindex_size,
|
|
const mwIndex* colindex,
|
|
mwSize data_size,
|
|
const mxLogical* rData,
|
|
mwSize num_rows,
|
|
mwSize num_cols,
|
|
mwSize nzmax
|
|
);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetLogicalSparseInferRowsCols(
|
|
void** ppv,
|
|
mwSize rowindex_size,
|
|
const mwIndex* rowindex,
|
|
mwSize colindex_size,
|
|
const mwIndex* colindex,
|
|
mwSize data_size,
|
|
const mxLogical* rData,
|
|
mwSize nzmax
|
|
);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclDeserializeArray(void** ppv, void** ppa);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclcppGetArrayBuffer(void** ppv, mwSize size);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclcppFeval(HMCRINSTANCE inst, const char* name, int nargout, void** lhs, void* rhs);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclcppArrayToString(mxArray* parray, char** ppstr);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void mclcppFreeString(char* pstr);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclmxArray2ArrayHandle(void** pphArray, mxArray* pmxArray);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclArrayHandle2mxArray(mxArray** ppArrayImpl, void* phArray);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMXArrayGetIndexArrays(mxArray** ppRows, mxArray** ppColumns, mxArray* pSrcArray);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMXArrayGet(mxArray** ppSrcElem, mxArray* pSrcArray, mwSize num_indices, const mwIndex* index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMXArrayGetReal(mxArray** ppSrcElem, mxArray* pSrcArray, mwSize num_indices, const mwIndex* index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMXArrayGetImag(mxArray** ppSrcElem, mxArray* pSrcArray, mwSize num_indices, const mwIndex* index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMXArraySet(mxArray* pTrgArray, mxArray* pSrcElem, mwSize num_indices, const mwIndex* index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMXArraySetReal(mxArray* pTrgArray, mxArray* pSrcElem, mwSize num_indices, const mwIndex* index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMXArraySetImag(mxArray* pTrgArray, mxArray* pSrcElem, mwSize num_indices, const mwIndex* index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMXArraySetLogical(mxArray* pTrgArray, mxArray* pSrcElem, mwSize num_indices, const mwIndex* index);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void mclMxRefDestroyArray(mxArray* pa);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mxArray *mclMxRefSerialize(mxArray* pa);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mxArray *mclMxRefDeserialize(const void* pa,
|
|
size_t len, size_t mvmNumber);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C size_t mclMxRefMvmId(mxArray *pa);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C size_t mclHashNBytes(size_t u, size_t n, const char * pb);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mwIndex mclCalcSingleSubscript(const mxArray *pa, mwSize num_dims, const mwIndex* index);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mxArray* mclCreateCharMatrixFromUTF16Strings(mwSize m, const mxChar** strs);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mcl2DCharArrayToUTF16Strings(const mxArray* src, mxChar** data, mwSize* array_size);
|
|
|
|
#include "matrix.h"
|
|
|
|
|
|
#ifdef __cplusplus
|
|
/* This public extern "C" API provides functions to create and manipulate
|
|
* arrays. The API represents arrays as oqaque objects (void *'s, to be
|
|
* precise).
|
|
*
|
|
* The MATLAB Compiler and related Builder products use this API to insulate
|
|
* the generated code from changes in the underlying matrix data structure.
|
|
*/
|
|
|
|
|
|
|
|
/* Opaque handle type definition. */
|
|
typedef void * array_handle;
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mxClassID array_handle_classID(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_deep_copy(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void array_handle_detach(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_shared_copy(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_serialize(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C size_t array_handle_element_size(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mwSize array_handle_number_of_elements(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mwSize array_handle_number_of_nonzeros(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mwSize array_handle_maximum_nonzeros(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mwSize array_handle_number_of_dimensions(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_get_dimensions(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_number_of_fields(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C char_buffer* array_handle_get_field_name(array_handle handle, int i);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_handle_is_empty(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_handle_is_sparse(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_handle_is_numeric(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_handle_is_complex(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_make_complex(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool array_handle_equals(array_handle handle, array_handle p);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_compare_to(array_handle handle, array_handle p);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_hash_code(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C char_buffer* array_handle_to_string(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_row_index(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_column_index(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_get_int(array_handle handle, mwSize num_indices, const mwIndex* index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_get_const_char(array_handle handle, const char* name, mwSize num_indices, const mwIndex* index);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_getV_int(array_handle handle, mwSize num_indices, va_list vargs);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_getV_const_char(array_handle handle, const char* name, mwSize num_indices, va_list vargs);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set(array_handle handle, array_handle p);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_real(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C array_handle array_handle_imag(array_handle handle);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_numeric_mxDouble(array_handle handle, mxDouble* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_numeric_mxSingle(array_handle handle, mxSingle* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_numeric_mxInt8(array_handle handle, mxInt8* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_numeric_mxUint8(array_handle handle, mxUint8* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_numeric_mxInt16(array_handle handle, mxInt16* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_numeric_mxUint16(array_handle handle, mxUint16* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_numeric_mxInt32(array_handle handle, mxInt32* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_numeric_mxUint32(array_handle handle, mxUint32* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_numeric_mxInt64(array_handle handle, mxInt64* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_numeric_mxUint64(array_handle handle, mxUint64* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_char(array_handle handle, mxChar* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_get_logical(array_handle handle, mxLogical* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_numeric_mxDouble(array_handle handle, const mxDouble* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_numeric_mxSingle(array_handle handle, const mxSingle* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_numeric_mxInt8(array_handle handle, const mxInt8* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_numeric_mxUint8(array_handle handle, const mxUint8* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_numeric_mxInt16(array_handle handle, const mxInt16* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_numeric_mxUint16(array_handle handle, const mxUint16* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_numeric_mxInt32(array_handle handle, const mxInt32* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_numeric_mxUint32(array_handle handle, const mxUint32* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_numeric_mxInt64(array_handle handle, const mxInt64* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_numeric_mxUint64(array_handle handle, const mxUint64* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_char(array_handle handle, const mxChar* x, mwSize len);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int array_handle_set_logical(array_handle handle, const mxLogical* x, mwSize len);
|
|
|
|
|
|
#endif /* #ifdef __cplusplus */
|
|
|
|
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include <wchar.h>
|
|
|
|
|
|
#ifdef __cplusplus
|
|
class MclMcr {};
|
|
#endif
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclWrite(int fd, const void *ptr, size_t count);
|
|
|
|
|
|
|
|
/* define MW_CALL_CONV to __cdecl if building on windows */
|
|
#ifndef MW_CALL_CONV
|
|
#if defined( _MSC_VER) || defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__LCC__)
|
|
#define MW_CALL_CONV __cdecl
|
|
#else
|
|
#define MW_CALL_CONV
|
|
#endif /* using some PC compiler */
|
|
#endif /* MW_CALL_CONV */
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
typedef void (*mclErrorCallbackFcnPtr)(void);
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void mclAddCanonicalPathMacro(const char* macro, const char* expansion);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclFeval(HMCRINSTANCE inst, const char* name, int nlhs, mxArray** plhs, int nrhs, mxArray** prhs);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclGetMaxPathLen(void);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclmcrInitialize2(int primaryMode);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclmcrInitialize(void);
|
|
|
|
|
|
|
|
/*
|
|
* in LCC, int32_t is defined as a long since it does not
|
|
* contain a definition for __int32, this is MSVC specific.
|
|
*/
|
|
#ifdef _WIN32
|
|
#ifdef __LCC__
|
|
typedef long int32_t;
|
|
#else
|
|
typedef __int32 int32_t;
|
|
#endif
|
|
#endif
|
|
|
|
#define MAX_FIELD_NAME_SIZE 1024
|
|
|
|
typedef struct _wcsStackPointer
|
|
{
|
|
CHAR16_T * hPtr;
|
|
CHAR16_T sPtr[MAX_FIELD_NAME_SIZE];
|
|
int32_t buffLen;
|
|
} *pwcsStackPointer;
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void deleteWcsStackPointer_hPtr(pwcsStackPointer ptr);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void initializeWcsStackPointer(pwcsStackPointer *ptr);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void deleteWcsStackPointer(pwcsStackPointer ptr);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool allocWcsStackPointer(pwcsStackPointer *ptr, int newLen);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mwMbstowcs(pwcsStackPointer sp, const char *sourceString);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void utf16_to_lcp_n_fcn(char * target, int32_t * targetSize,
|
|
CHAR16_T const * source, int32_t sourceSize);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int32_t utf16_strlen_fcn(CHAR16_T const * s);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C CHAR16_T * utf16_strncpy_fcn(CHAR16_T * dst, CHAR16_T const * src, int32_t n);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C CHAR16_T * utf16_strdup_fcn(const CHAR16_T * sl);
|
|
|
|
|
|
|
|
/* PATH_MAX is the maximum number of characters that can appear in a full
|
|
* path specification. Define it, if it isn't already defined.
|
|
*/
|
|
|
|
#if !defined(PATH_MAX) || (defined(PATH_MAX) && PATH_MAX<1024)
|
|
#undef PATH_MAX
|
|
|
|
/* _WIN32 is always defined, for both Win32 and Win64 platforms */
|
|
#ifdef _WIN32
|
|
#ifdef _MAX_PATH
|
|
#define PATH_MAX _MAX_PATH
|
|
#endif
|
|
#endif
|
|
|
|
/* Windows platforms on which _MAX_PATH is not defined, and all UNIX
|
|
* platforms that don't define PATH_MAX. (Most UNIX platforms should
|
|
* define PATH_MAX in <limits.h>)
|
|
*/
|
|
#ifndef PATH_MAX
|
|
#define PATH_MAX 1024
|
|
#endif
|
|
|
|
#endif
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclFeval(HMCRINSTANCE inst, const char* name, int nlhs, mxArray** plhs, int nrhs, mxArray** prhs);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclSetGlobal(HMCRINSTANCE inst, const char* name, mxArray* px);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclIsStandaloneMode();
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclImpersonationFeval(HMCRINSTANCE inst, const char* name, int nlhs, mxArray** plhs, int nrhs, mxArray** prhs, void* impersonationToken);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclFeval(HMCRINSTANCE inst, const char* name, int nlhs, mxArray** plhs, int nrhs, mxArray** prhs);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclGetGlobal(HMCRINSTANCE inst, const char* name, mxArray** ppx);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C long mclGetID(HMCRINSTANCE inst);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C int mclMain(HMCRINSTANCE inst, int argc, const char* argv[],
|
|
const char* name, int nlhs);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclMlfVFeval(HMCRINSTANCE inst, const char* name, int nargout, int fnout, int fnin, va_list ap);
|
|
|
|
|
|
typedef void (*mclEventFunctionPtr)(void * context, int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclSetGlobal(HMCRINSTANCE inst, const char* name, mxArray* px);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclGetMCRVersion(const char **version);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C size_t mclGetActiveID(void);
|
|
|
|
|
|
typedef int (*mclOutputFcnCpp)(const char *);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C char* mclGetTempFileName(char* tempFileName);
|
|
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclTerminateInstance(HMCRINSTANCE* inst);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void stopImpersonationOnMCRThread(HMCRINSTANCE inst);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclMxIsA(HMCRINSTANCE inst, mxArray* pa, const char *cname);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclMxIsRef(mxArray* pa);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclMxRefIsA(mxArray* pa,
|
|
const char *cname);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C const char* mclMxRefGetRefClassName(const mxArray *pa);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C
|
|
mxArray *mclMxRefGetProperty(const mxArray *obj, mwIndex index,
|
|
const char *propName);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C
|
|
void mclMxRefSetProperty(mxArray *obj, mwIndex index,
|
|
const char *propName, const mxArray *propValue);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C mxArray* mclMxReleaseRef(mxArray * pa);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C MVMID_t mclMxRefLocalMvm(mxArray *pa);
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void mclMxDestroyArray(HMCRINSTANCE inst, mxArray* pa );
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C void mclNonDefaultAppDomainInUse();
|
|
|
|
LIBMWMCLMCR_API_EXTERN_C bool mclIsNonDefaultAppDomainInUse();
|
|
|
|
#endif /* mclmcr_published_api_hpp */
|