/* * PUBLISHED header for emlrt, the runtime library for MATLAB Coder * * Copyright 1984-2021 The MathWorks, Inc. * */ #ifndef emlrt_h #define emlrt_h #if defined(_MSC_VER) || defined(__GNUC__) #pragma once #endif /* * Only define EXTERN_C if it hasn't been defined already. This allows * individual modules to have more control over managing their exports. */ #ifndef EXTERN_C #ifdef __cplusplus #define EXTERN_C extern "C" #else #define EXTERN_C extern #endif #endif #ifndef LIBEMLRT_API #define LIBEMLRT_API #endif #if defined(BUILDING_LIBEMLRT) #include "emlrt_extern_include_begin.hpp" #endif #include "matrix.h" #if defined(BUILDING_LIBEMLRT) #include "emlrt_extern_include_end.hpp" #endif #include #include #include /* Incomplete typedef for mxGPUArray */ #ifndef MX_GPUARRAY_DEFINED #ifdef __cplusplus class mxGPUArray; #else typedef struct mxGPUArray_tag mxGPUArray; #endif /*lint -esym(1923,MX_GPUARRAY_DEFINED) // MACRO input cannot be converted to const variable in C*/ #define MX_GPUARRAY_DEFINED 1.0 #endif /* * MATLAB INTERNAL USE ONLY :: MEX Version */ #define EMLRT_VERSION_R2021B 0x2021B #define EMLRT_VERSION_INFO EMLRT_VERSION_R2021B /* * MATLAB INTERNAL USE ONLY :: Thread local context type */ typedef void* emlrtCTX; typedef const void* emlrtConstCTX; /* * MATLAB INTERNAL USE ONLY :: MEX error function */ typedef void (*EmlrtErrorFunction)(const char* aIdentifier, const CHAR16_T* aMessage, emlrtCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Prototypes of OpenMP lock functions. */ typedef void (*EmlrtLockeeFunction)(emlrtConstCTX aTLS, void* aData); typedef void (*EmlrtLockerFunction)(EmlrtLockeeFunction aLockee, emlrtConstCTX aTLS, void* aData); #define emlrtCallLockeeFunction(emlrtLockeeFcnPtr, emlrtLockeeArg0, emlrtLockeeArg1) \ emlrtLockeeFcnPtr(emlrtLockeeArg0, emlrtLockeeArg1) /* * MATLAB INTERNAL USE ONLY :: Runtime message identifier */ typedef struct emlrtMsgIdentifier { const char* fIdentifier; const struct emlrtMsgIdentifier* fParent; boolean_T bParentIsCell; } emlrtMsgIdentifier; /* * MATLAB INTERNAL USE ONLY :: Runtime stack info */ typedef struct emlrtRSInfo { int32_T lineNo; const char* fcnName; const char* pathName; } emlrtRSInfo; /* * MATLAB INTERNAL USE ONLY :: Runtime call stack */ typedef struct emlrtStack { emlrtRSInfo* site; emlrtCTX tls; const struct emlrtStack* prev; } emlrtStack; /* * MATLAB INTERNAL USE ONLY :: Runtime call stack */ typedef struct emlrtCallStack { uint32_T fRTStackPointer; uint32_T* fRTStackSize; } emlrtCallStack; /* * MATLAB INTERNAL USE ONLY :: MEX Context */ typedef struct emlrtContext { boolean_T bFirstTime; boolean_T bInitialized; uint32_T fVersionInfo; EmlrtErrorFunction fErrorFunction; const char* fFunctionName; struct emlrtCallStack* fRTCallStack; boolean_T bDebugMode; uint32_T fSigWrd[4]; void* fSigMem; } emlrtContext; /* * MATLAB INTERNAL USE ONLY :: External Mode Simulation */ typedef struct emlrtExternalSim { void* fESim; uint8_T* fIOBuffer; uint8_T* fIOBufHead; size_t fIOBufSize; } emlrtExternalSim; /* * MATLAB INTERNAL USE ONLY :: Array bounds check parameters */ typedef struct emlrtBCInfo { int32_T iFirst; int32_T iLast; int32_T lineNo; int32_T colNo; const char* aName; const char* fName; const char* pName; int32_T checkKind; } emlrtBCInfo; /* * MATLAB INTERNAL USE ONLY :: Design range check parameters */ typedef struct emlrtDRCInfo { int32_T lineNo; int32_T colNo; const char* fName; const char* pName; } emlrtDRCInfo; /* * MATLAB INTERNAL USE ONLY :: Equality check parameters */ typedef struct emlrtECInfo { int32_T nDims; int32_T lineNo; int32_T colNo; const char* fName; const char* pName; } emlrtECInfo; /* * MATLAB INTERNAL USE ONLY :: Array bounds check parameters */ typedef struct { int32_T lineNo; int32_T colNo; const char* fName; const char* pName; } emlrtRTEInfo; typedef emlrtRTEInfo emlrtMCInfo; /* MATLAB INTERNAL USE ONLY :: Reference to global runtime context */ extern emlrtContext emlrtContextGlobal; /* * MATLAB INTERNAL USE ONLY :: Dispatch to mexPrintf */ EXTERN_C LIBEMLRT_API int32_T emlrtMexVprintf(const char* aFmt, va_list aVargs); /* * MATLAB INTERNAL USE ONLY :: Dispatch to mexPrintf */ EXTERN_C LIBEMLRT_API int32_T emlrtMexPrintf(emlrtConstCTX aTLS, const char* aFmt, ...); /* * MATLAB INTERNAL USE ONLY :: Dispatch to snprintf */ EXTERN_C LIBEMLRT_API int32_T emlrtMexSnprintf(char* retString, size_t n, const char* aFmt, ...); /* * MATLAB INTERNAL USE ONLY :: Query first-time sentinel */ EXTERN_C LIBEMLRT_API boolean_T emlrtFirstTimeR2012b(emlrtCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Create an mxArray alias */ EXTERN_C LIBEMLRT_API const mxArray* emlrtAlias(const mxArray* in); /* * MATLAB INTERNAL USE ONLY :: Create a persistent mxArray alias */ EXTERN_C LIBEMLRT_API const mxArray* emlrtAliasP(const mxArray* in); /* * MATLAB INTERNAL USE ONLY :: Return a vector of mxArray to MATLAB */ EXTERN_C LIBEMLRT_API void emlrtReturnArrays(const int32_T aNlhs, mxArray* aLHS[], const mxArray* const aRHS[]); /* * MATLAB INTERNAL USE ONLY :: Protect mxArray from being overwritten if necessary */ EXTERN_C LIBEMLRT_API const mxArray* emlrtProtectR2012b(const mxArray* pa, int32_T, boolean_T, int32_T reservedNumEl); /* * MATLAB INTERNAL USE ONLY :: License check */ EXTERN_C LIBEMLRT_API void emlrtLicenseCheckR2012b(emlrtCTX aTLS, const char* aFeatureKey, const int32_T b); /* * MATLAB INTERNAL USE ONLY :: Verify default fimath */ EXTERN_C LIBEMLRT_API void emlrtCheckDefaultFimathR2008b(const mxArray** ctFimath); /* * MATLAB INTERNAL USE ONLY :: Clear mxArray allocation count */ EXTERN_C LIBEMLRT_API void emlrtClearAllocCountR2012b(emlrtCTX aTLS, boolean_T bM, uint32_T iL, const char* ctDTO); /* * MATLAB INTERNAL USE ONLY :: Load a specified library */ EXTERN_C LIBEMLRT_API int32_T emlrtLoadLibrary(const char* aFullname); /* * MATLAB INTERNAL USE ONLY :: Load a specified MATLAB library */ EXTERN_C LIBEMLRT_API int32_T emlrtLoadMATLABLibrary(const char* aFullName); /* * MATLAB INTERNAL USE ONLY :: Assign to an mxArray */ EXTERN_C LIBEMLRT_API void emlrtAssign(const mxArray** lhs, const mxArray* rhs); /* * MATLAB INTERNAL USE ONLY :: Assign to a persistent mxArray */ EXTERN_C LIBEMLRT_API void emlrtAssignP(const mxArray** lhs, const mxArray* rhs); /* * MATLAB INTERNAL USE ONLY :: Array bounds check */ EXTERN_C LIBEMLRT_API int32_T emlrtBoundsCheckR2012b(int32_T indexValue, emlrtBCInfo* aInfo, emlrtCTX aTLS); #ifdef INT_TYPE_64_IS_SUPPORTED /* * MATLAB INTERNAL USE ONLY :: Array bounds check for int64 */ EXTERN_C LIBEMLRT_API int64_T emlrtBoundsCheckInt64(const int64_T indexValue, const emlrtBCInfo* const aInfo, const emlrtCTX aTLS); #endif /* * MATLAB INTERNAL USE ONLY :: Dynamic array bounds check */ EXTERN_C LIBEMLRT_API int32_T emlrtDynamicBoundsCheckR2012b(int32_T indexValue, int32_T loBound, int32_T hiBound, emlrtBCInfo* aInfo, emlrtConstCTX aTLS); #ifdef INT_TYPE_64_IS_SUPPORTED /* * MATLAB INTERNAL USE ONLY :: Dynamic array bounds check for int64 */ EXTERN_C LIBEMLRT_API int64_T emlrtDynamicBoundsCheckInt64(const int64_T indexValue, const int32_T loBound, const int32_T hiBound, const emlrtBCInfo* const aInfo, const emlrtConstCTX aTLS); #endif /* * MATLAB INTERNAL USE ONLY :: Check that the target value is within the design range. */ EXTERN_C LIBEMLRT_API real_T emlrtDesignRangeCheck(real_T targetValue, real_T rangeMin, real_T rangeMax, emlrtDRCInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Perform integer multiplication, raise runtime error * if the operation overflows. */ EXTERN_C LIBEMLRT_API size_t emlrtSizeMulR2012b(size_t s1, size_t s2, const emlrtRTEInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Create an mxArray string from a C string */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateString(const char* in); /* * MATLAB INTERNAL USE ONLY :: Create an mxArray string from a single char */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateString1(char c); /* * MATLAB INTERNAL USE ONLY :: Create a struct matrix mxArray */ EXTERN_C LIBEMLRT_API mxArray* emlrtCreateStructMatrix(int32_T m, int32_T n, int32_T nfields, const char** field_names); /* * MATLAB INTERNAL USE ONLY :: Create a class instance mxArray */ EXTERN_C LIBEMLRT_API mxArray* emlrtCreateClassInstance(const char* className); /* * MATLAB INTERNAL USE ONLY :: Create a struct matrix mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateStructArray(int32_T ndim, const int32_T* pdim, int32_T nfields, const char** field_names); /* * MATLAB INTERNAL USE ONLY :: Create an enum */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateEnumR2012b(emlrtConstCTX aTLS, const char* name, const mxArray* data); /* * MATLAB INTERNAL USE ONLY :: Add a field to a struct matrix mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateField(const mxArray* mxStruct, const char* fldName); /* * MATLAB INTERNAL USE ONLY :: Check an input sparse matrix */ EXTERN_C LIBEMLRT_API void emlrtCheckSparse(emlrtConstCTX aTLS, const emlrtMsgIdentifier* aMsgId, const mxArray* s, const void* pDims, const boolean_T* aDynamic, int32_T aClassId, int32_T aComplexity); /* * MATLAB INTERNAL USE ONLY :: Polymorphic mex utility functions */ EXTERN_C LIBEMLRT_API const char* emlrtGetClassName(const mxArray* pa); EXTERN_C LIBEMLRT_API boolean_T emlrtCompareString(const char* actual, const char* expected); EXTERN_C LIBEMLRT_API boolean_T emlrtIsComplex(const mxArray* pa); EXTERN_C LIBEMLRT_API boolean_T emlrtIsHeterogeneous(const mxArray* pa); EXTERN_C LIBEMLRT_API int emlrtNumCellElements(const mxArray* pa); EXTERN_C LIBEMLRT_API mxArray* emlrtGetCellElement(const mxArray* pa, int index); EXTERN_C LIBEMLRT_API int emlrtGetNumStructFields(const mxArray* pa); EXTERN_C LIBEMLRT_API const char* emlrtGetStructFieldName(const mxArray* pa, int index); EXTERN_C LIBEMLRT_API mxArray* emlrtGetStructField(const mxArray* pa, const char* fieldName); EXTERN_C LIBEMLRT_API boolean_T emlrtIsCompatibleSize(const mxArray* pa, const uint32_T* aSizeVec, const boolean_T* aVardimVec, const uint32_T sizeLength); EXTERN_C LIBEMLRT_API boolean_T emlrtIsSparse(const mxArray* pa); EXTERN_C LIBEMLRT_API uint32_T emlrtGetSizeLength(const mxArray* pa); EXTERN_C LIBEMLRT_API mxArray* emlrtGetClassProperty(const mxArray* pa, const char* propertyName); EXTERN_C LIBEMLRT_API boolean_T emlrtCompareFiType(const mxArray* aFi, const mxArray* fiMathMx, const mxArray* ntMx); EXTERN_C LIBEMLRT_API boolean_T emlrtIsComplexFi(const mxArray* aFi); EXTERN_C LIBEMLRT_API boolean_T emlrtCompareConstant(const mxArray* aConst, const uint32_T* aCheckSum); /* * MATLAB INTERNAL USE ONLY :: Check an input sparse matrix */ EXTERN_C LIBEMLRT_API mxArray* emlrtCreateSparse(const void* d, const int32_T* colidx, const int32_T* rowidx, int32_T m, int32_T n, int32_T maxnz, int32_T aClassId, int32_T aComplexity); /* * MATLAB INTERNAL USE ONLY :: Add a field to a struct matrix mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtAddField(const mxArray* mxStruct, const mxArray* mxField, const char* fldName, int32_T index); /* * MATLAB INTERNAL USE ONLY :: Set the value from propValues of all properties in propNames of a * class instance mxArray. */ EXTERN_C LIBEMLRT_API void emlrtSetAllProperties(emlrtConstCTX, const mxArray**, int32_T index, int32_T numberOfProperties, const char** propertyNames, const char** classNames, const mxArray** propertyValues); /* * MATLAB INTERNAL USE ONLY :: Get the value mxArray of all properties of a class instance mxArray. */ EXTERN_C LIBEMLRT_API void emlrtGetAllProperties(emlrtConstCTX, const mxArray*, int32_T index, int32_T numberOfProperties, const char** propertyNames, const char** classNames, const mxArray** propertyValues); /* * MATLAB INTERNAL USE ONLY :: Get the redirect target MCOS instance mxArray of a redirect source * MCOS instance mxArray. */ EXTERN_C LIBEMLRT_API const mxArray* emlrtConvertInstanceToRedirectTarget(emlrtConstCTX aTLS, const mxArray* mxCls, int aIndex, const char* className); /* * MATLAB INTERNAL USE ONLY :: Get the redirect source MCOS instance mxArray of a redirect target * MCOS instance mxArray. */ EXTERN_C LIBEMLRT_API const mxArray* emlrtConvertInstanceToRedirectSource(emlrtConstCTX aTLS, const mxArray* mxCls, int aIndex, const char* className); /* * MATLAB INTERNAL USE ONLY :: Get a field from a struct matrix mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtGetFieldR2017b(emlrtConstCTX aTLS, const mxArray* mxStruct, int32_T aIndex, int32_T fldNumber, const char* fldName); /* * MATLAB INTERNAL USE ONLY :: Set field value in structure array, given index and field name */ EXTERN_C LIBEMLRT_API void emlrtSetField(mxArray* mxStruct, int32_T aIndex, const char* fldName, mxArray* mxValue); /* * MATLAB INTERNAL USE ONLY :: Set field value in structure array, given index and field index */ EXTERN_C LIBEMLRT_API void emlrtSetFieldR2017b(const mxArray* mxStruct, int32_T aIndex, const char* fldName, const mxArray* mxValue, int32_T fldIdx); /* * MATLAB INTERNAL USE ONLY :: Create a cell array */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateCellArrayR2014a(int32_T ndim, const int32_T* pdim); /* * MATLAB INTERNAL USE ONLY :: Create a cell matrix mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateCellMatrix(int32_T m, int32_T n); /* * MATLAB INTERNAL USE ONLY :: Set a cell element */ EXTERN_C LIBEMLRT_API const mxArray* emlrtSetCell(const mxArray* mxCellArray, int32_T aIndex, const mxArray* mxCell); /* * MATLAB INTERNAL USE ONLY :: Get a cell element */ EXTERN_C LIBEMLRT_API const mxArray* emlrtGetCell(emlrtConstCTX aTLS, const emlrtMsgIdentifier* aMsgId, const mxArray* mxCell, int32_T aIndex); /* * MATLAB INTERNAL USE ONLY :: Check if empty */ EXTERN_C LIBEMLRT_API boolean_T emlrtIsEmpty(const mxArray* mxCell); /* * MATLAB INTERNAL USE ONLY :: Create a numeric matrix mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateNumericMatrix(int32_T m, int32_T n, int32_T classID, int32_T nComplexFlag); /* * MATLAB INTERNAL USE ONLY :: Create a numeric matrix mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateNumericArray(int32_T ndim, const void* pdim, int32_T classID, int32_T nComplexFlag); /* * MATLAB INTERNAL USE ONLY :: Create a scaled numeric matrix mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateScaledNumericArrayR2008b(int32_T ndim, const void* pdim, int32_T classID, int32_T nComplexFlag, int32_T aScale); /* * MATLAB INTERNAL USE ONLY :: Create a double scalar mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateDoubleScalar(real_T in); /* * MATLAB INTERNAL USE ONLY :: Create a logical matrix mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateLogicalArray(int32_T ndim, const int32_T* dims); /* * MATLAB INTERNAL USE ONLY :: Create a 2-D logical matrix mxArray */ EXTERN_C LIBEMLRT_API mxArray* emlrtCreateLogicalMatrix(int32_T aN, int32_T aM); /* * MATLAB INTERNAL USE ONLY :: Create a logical scalar mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateLogicalScalar(boolean_T in); /* * MATLAB INTERNAL USE ONLY :: Create a character array mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateCharArray(int32_T ndim, const int32_T* dims); /* * MATLAB INTERNAL USE ONLY :: Create a FI mxArray from a value mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateFIR2013b(emlrtConstCTX aTLS, const mxArray* fimath, const mxArray* ntype, const char* fitype, const mxArray* fival, const boolean_T fmIsLocal, const boolean_T aForceComplex); /* * MATLAB INTERNAL USE ONLY :: Set the dimensions of an mxArray. */ EXTERN_C LIBEMLRT_API int32_T emlrtSetDimensions(mxArray* aMx, const int32_T* dims, int32_T ndims); /* * MATLAB INTERNAL USE ONLY :: Get the intarray from a FI mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtImportFiIntArrayR2008b(const mxArray* aFiMx); /* * MATLAB INTERNAL USE ONLY :: Get the enum int32_T from an MCOS enumeration mxArray. */ EXTERN_C LIBEMLRT_API int32_T emlrtGetEnumElementR2009a(const mxArray* aEnum, int32_T aIndex); /* * MATLAB INTERNAL USE ONLY :: Get the enum int32_T from an MCOS enumeration mxArray. */ EXTERN_C LIBEMLRT_API const mxArray* emlrtGetEnumUnderlyingArrayR2009a(const mxArray* aEnum); /* * MATLAB INTERNAL USE ONLY :: Convert MATLAB mxArray data format to C data format */ EXTERN_C LIBEMLRT_API void emlrtMatlabDataToCFormat(const mxArray* inputMx, const mxArray* cformatMx); /* * MATLAB INTERNAL USE ONLY :: Convert C data format to MATLAB data format */ EXTERN_C LIBEMLRT_API void emlrtMatlabDataFromCFormat(const mxArray* outputMx, const mxArray* cformatMx); /* * MATLAB INTERNAL USE ONLY :: Try to coerce mxArray to provided class; return same mxArray if not * possible. */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCoerceToClassR2014b(const mxArray* inputMx, const char* className); /* * MATLAB INTERNAL USE ONLY :: Destroy an mxArray */ EXTERN_C LIBEMLRT_API void emlrtDestroyArray(const mxArray** pa); /* * MATLAB INTERNAL USE ONLY :: Destroy an mxArray R2017a */ EXTERN_C LIBEMLRT_API void emlrtDestroyArrayR2017a(mxArray* pa); /* * MATLAB INTERNAL USE ONLY :: Destroy a vector of mxArrays */ EXTERN_C LIBEMLRT_API void emlrtDestroyArrays(int32_T narrays, const mxArray** parrays); /* * MATLAB INTERNAL USE ONLY :: Free the imaginary part of a matrix if all the imaginary elements are * zero */ EXTERN_C LIBEMLRT_API void emlrtFreeImagIfZero(const mxArray* pa); /* * MATLAB INTERNAL USE ONLY :: Display an mxArray */ EXTERN_C LIBEMLRT_API void emlrtDisplayR2012b(const mxArray* pa, const char* name, emlrtMCInfo* aLoc, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Double check parameters */ typedef struct { int32_T lineNo; int32_T colNo; const char* fName; const char* pName; int32_T checkKind; /* see src/cg_ir/base/Node.hpp::CG_Node_CheckEnum */ } emlrtDCInfo; /* * MATLAB INTERNAL USE ONLY :: Check that d can be safely cast to int. */ EXTERN_C LIBEMLRT_API real_T emlrtIntegerCheckR2012b(real_T d, emlrtDCInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Check that d is not NaN. */ EXTERN_C LIBEMLRT_API real_T emlrtNotNanCheckR2012b(real_T d, emlrtDCInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Check that d >= 0. */ EXTERN_C LIBEMLRT_API real_T emlrtNonNegativeCheckR2012b(real_T d, emlrtDCInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Check that the loop has an integer number of iterations. */ EXTERN_C LIBEMLRT_API void emlrtForLoopVectorCheckR2012b(real_T start, real_T step, real_T end, mxClassID classID, int32_T n, emlrtRTEInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Check that the loop range is valid for code generation. */ EXTERN_C LIBEMLRT_API void emlrtForLoopVectorCheckR2021a(real_T start, real_T step, real_T end, mxClassID classID, int32_T n, emlrtRTEInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: fetch a global variable */ EXTERN_C LIBEMLRT_API void emlrtPutGlobalVariable(const char* name, const mxArray* parray); /* * MATLAB INTERNAL USE ONLY :: fetch a global variable */ EXTERN_C LIBEMLRT_API const mxArray* emlrtGetGlobalVariable(const char* name); /* * MATLAB INTERNAL USE ONLY :: Call out to MATLAB to report error from MLFB/Stateflow */ EXTERN_C LIBEMLRT_API const mxArray* emlrtSFCallMATLABReportError(emlrtConstCTX aTLS, emlrtMCInfo* aLoc, int32_T nrhs, const mxArray** prhs); /* * MATLAB INTERNAL USE ONLY :: Extract the C stack from emlrtConstCtx */ EXTERN_C LIBEMLRT_API mxArray* emlrtExtractStack(emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Call out to MATLAB */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCallMATLABR2012b(emlrtConstCTX aTLS, int32_T nlhs, const mxArray** plhs, int32_T nrhs, const mxArray** prhs, const char* cmd, boolean_T tmp, emlrtMCInfo* aLoc); /* * MATLAB INTERNAL USE ONLY :: malloc for MEX */ EXTERN_C LIBEMLRT_API void* emlrtMallocMex(size_t aSize); /* * MATLAB INTERNAL USE ONLY :: calloc for MEX */ EXTERN_C LIBEMLRT_API void* emlrtCallocMex(size_t aNum, size_t aSize); /* * MATLAB INTERNAL USE ONLY :: free for MEX */ EXTERN_C LIBEMLRT_API void emlrtFreeMex(void* aPtr); /* * MATLAB INTERNAL USE ONLY :: malloc for EmxArrays */ EXTERN_C LIBEMLRT_API void* emlrtMallocEmxArray(size_t aSize); /* * MATLAB INTERNAL USE ONLY :: free for EmxArrays */ EXTERN_C LIBEMLRT_API void emlrtFreeEmxArray(void* aPtr); /* * MATLAB INTERNAL USE ONLY :: Enter a new function within a MEX call. */ EXTERN_C LIBEMLRT_API void emlrtHeapReferenceStackEnterFcnR2012b(emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Enter a new function within a MEX call. */ EXTERN_C LIBEMLRT_API void emlrtHeapReferenceStackEnterFcn(void); /* * MATLAB INTERNAL USE ONLY :: Leave a scope within a MEX call. */ EXTERN_C LIBEMLRT_API void emlrtHeapReferenceStackLeaveScope(emlrtConstCTX aTLS, int32_T aAllocCount); /* * MATLAB INTERNAL USE ONLY :: Leave a function within a MEX call. */ EXTERN_C LIBEMLRT_API void emlrtHeapReferenceStackLeaveFcnR2012b(emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Leave a function within a MEX call. */ EXTERN_C LIBEMLRT_API void emlrtHeapReferenceStackLeaveFcn(void); EXTERN_C LIBEMLRT_API void emlrtPushHeapReferenceStackR2021a(emlrtConstCTX aTLS, bool aNeedStack, void* aHeapReference, void* aFreeFcn, void* aSimStruct, void* aJITInstance, void* aStackData); /* * MATLAB INTERNAL USE ONLY :: Push emxArray onto heap reference stack. */ EXTERN_C LIBEMLRT_API void emlrtPushHeapReferenceStackEmxArray(emlrtConstCTX aTLS, bool aNeedStack, void* aHeapReference, void* aFreeFcn, void* aSimStruct, void* aJITInstance, void* aStackData); EXTERN_C LIBEMLRT_API void emlrtRemoveHeapReference(emlrtConstCTX aTLS, void* aHeapReference); /* * MATLAB INTERNAL USE ONLY :: Push a new entry to the heap reference stack. */ EXTERN_C LIBEMLRT_API void emlrtSetGlobalSyncFcn(emlrtConstCTX aTLS, void* aSyncFcn); /* * MATLAB INTERNAL USE ONLY :: Push a new entry to the heap reference stack. */ EXTERN_C LIBEMLRT_API void emlrtSetGlobalSyncFcnWithSD(emlrtConstCTX aTLS, void* aStackData, void* aSyncFcn); /* * MATLAB INTERNAL USE ONLY :: Push a new entry to the heap reference stack. */ EXTERN_C LIBEMLRT_API void emlrtSetJITGlobalSyncFcn(emlrtConstCTX aTLS, void* aJITInstance, void* aSyncFcn); /* * MATLAB INTERNAL USE ONLY :: Push a new entry to the heap reference stack. */ EXTERN_C LIBEMLRT_API void emlrtSetJITGlobalSyncFcnWithSD(emlrtConstCTX aTLS, void* aJITInstance, void* aStackData, void* aSyncFcn); /* * MATLAB INTERNAL USE ONLY :: Initialize a character mxArray */ EXTERN_C LIBEMLRT_API void emlrtInitCharArrayR2013a(emlrtConstCTX aTLS, int32_T n, const mxArray* a, const char* s); /* * MATLAB INTERNAL USE ONLY :: Initialize a logical mxArray */ EXTERN_C LIBEMLRT_API void emlrtInitLogicalArray(int32_T n, const mxArray* a, const boolean_T* b); /* * MATLAB INTERNAL USE ONLY :: Initialize an integral array from a multiword type */ EXTERN_C LIBEMLRT_API void emlrtInitIntegerArrayFromMultiword(const mxArray* aOut, const void* aInData); /* * MATLAB INTERNAL USE ONLY :: Export a numeric mxArray */ EXTERN_C LIBEMLRT_API void emlrtExportNumericArrayR2013b(emlrtConstCTX aTLS, const mxArray* aOut, const void* aInData, int32_T aElementSize); /* * MATLAB INTERNAL USE ONLY :: Auto-generated mexFunction */ typedef void (*emlrtMexFunction)(int, mxArray*[], int, const mxArray*[]); /* * MATLAB INTERNAL USE ONLY :: Auto-generated entry-point */ typedef struct emlrtEntryPoint { const char* fName; emlrtMexFunction fMethod; } emlrtEntryPoint; /* * MATLAB INTERNAL USE ONLY :: Lookup an entry point */ EXTERN_C LIBEMLRT_API int32_T emlrtGetEntryPointIndexR2016a(emlrtConstCTX aTLS, int32_T nrhs, const mxArray* prhs[], const char* aEntryPointNames[], int32_T aNumEntryPoints); /* * MATLAB INTERNAL USE ONLY :: Decode wide character strings in mxArray struct array. * The struct array consists of name resolution entries which may contain file paths. * If the file path is using UTF-8, then the string is plain 7-bit ASCII but encoded. * We need to decode those if necessary. The resulting mxArray strings (for file paths) * will be proper UTF-16 strings. */ EXTERN_C LIBEMLRT_API void emlrtNameCapturePostProcessR2013b(const mxArray** mxInfo); /* * MATLAB INTERNAL USE ONLY :: Decode string array into mxArray object containing * name resolution data. */ EXTERN_C LIBEMLRT_API void emlrtNameCaptureMxArrayR2016a(const char* mxInfoEncoded[], uint32_T uncompressedSize, const mxArray** mxInfo); /* * MATLAB INTERNAL USE ONLY :: Parallel runtime error exception */ #ifdef __cplusplus class EmlrtParallelRunTimeError { public: EmlrtParallelRunTimeError(); EmlrtParallelRunTimeError(const EmlrtParallelRunTimeError& e); ~EmlrtParallelRunTimeError(); }; #endif /* * MATLAB INTERNAL USE ONLY :: Report if we are in a parallel region */ EXTERN_C LIBEMLRT_API boolean_T emlrtIsInParallelRegion(emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Enter a parallel region. */ EXTERN_C LIBEMLRT_API void emlrtEnterParallelRegion(emlrtConstCTX aTLS, boolean_T aInParallelRegion); /* * MATLAB INTERNAL USE ONLY :: Exit a parallel region. */ EXTERN_C LIBEMLRT_API void emlrtExitParallelRegion(emlrtConstCTX aTLS, boolean_T aInParallelRegion); /* * MATLAB INTERNAL USE ONLY :: Check if we're running on the MATLAB thread. */ EXTERN_C LIBEMLRT_API boolean_T emlrtIsMATLABThread(emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Record the occurrence of a parallel warning. */ EXTERN_C LIBEMLRT_API boolean_T emlrtSetWarningFlag(emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Report a parallel runtime error */ EXTERN_C LIBEMLRT_API void emlrtReportParallelRunTimeError(emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Ensure active thread is MATLAB */ EXTERN_C LIBEMLRT_API void emlrtAssertMATLABThread(emlrtConstCTX aTLS, emlrtMCInfo* aLoc); /* * MATLAB INTERNAL USE ONLY :: Push the current jmp_buf environment */ EXTERN_C LIBEMLRT_API void emlrtPushJmpBuf(emlrtConstCTX aTLS, jmp_buf* volatile* aJBEnviron); /* * MATLAB INTERNAL USE ONLY :: Pop the current jmp_buf environment */ EXTERN_C LIBEMLRT_API void emlrtPopJmpBuf(emlrtConstCTX aTLS, jmp_buf* volatile* aJBEnviron); /* * MATLAB INTERNAL USE ONLY :: Set the current jmp_buf environment */ EXTERN_C LIBEMLRT_API void emlrtSetJmpBuf(emlrtConstCTX aTLS, jmp_buf* aJBEnviron); /* * MATLAB INTERNAL USE ONLY :: Get the current jmp_buf environment */ EXTERN_C LIBEMLRT_API jmp_buf* emlrtGetJmpBuf(emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Create a shallow copy of an mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateReference(const mxArray* pa); /* * MATLAB INTERNAL USE ONLY :: Division by zero error */ EXTERN_C LIBEMLRT_API void emlrtDivisionByZeroErrorR2012b(const emlrtRTEInfo* aInfo, emlrtConstCTX aTLS); EXTERN_C LIBEMLRT_API void emlrtDivisionByZeroWarningOrError2018b(const emlrtRTEInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Integer overflow error */ EXTERN_C LIBEMLRT_API void emlrtIntegerOverflowErrorR2012b(const emlrtRTEInfo* aInfo, emlrtConstCTX aTLS); EXTERN_C LIBEMLRT_API void emlrtIntegerOverflowWarningOrError2018b(const emlrtRTEInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Raise C heap allocation failure */ EXTERN_C LIBEMLRT_API void emlrtHeapAllocationErrorR2012b(const emlrtRTEInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Error with given message ID and args. */ EXTERN_C LIBEMLRT_API void emlrtErrorWithMessageIdR2018a(emlrtConstCTX aTLS, const emlrtRTEInfo* aInfo, const char* aMsgID, const char* aReportID, int aArgCount, ...); /* * MATLAB INTERNAL USE ONLY :: Error with given message ID and args. */ EXTERN_C LIBEMLRT_API void emlrtErrorWithMessageIdR2012b(emlrtConstCTX aTLS, const emlrtRTEInfo* aInfo, const char* aMsgID, int32_T aArgCount, ...); /* * MATLAB INTERNAL USE ONLY :: Error with given message ID and args. */ EXTERN_C LIBEMLRT_API void emlrtErrMsgIdAndTxt(emlrtCTX aTLS, const char* aMsgID, int32_T aArgCount, ...); /* * MATLAB INTERNAL USE ONLY :: Error with given message ID and explicit message text. */ EXTERN_C LIBEMLRT_API void emlrtErrMsgIdAndExplicitTxt(emlrtConstCTX aTLS, const emlrtRTEInfo* aInfo, const char* aMsgID, int32_T aStrlen, const char* aMsgTxt); /* * MATLAB INTERNAL USE ONLY :: Convert a message ID to a heap-allocated LCP string. * This function is used by Stateflow run-time library only. */ EXTERN_C LIBEMLRT_API char* emlrtTranslateMessageIDtoLCPstring(const char* aMsgID); /* * MATLAB INTERNAL USE ONLY :: Convert a UTF16 message string to a heap-allocated LCP string. * This function is used by Stateflow run-time library only. */ EXTERN_C LIBEMLRT_API char* emlrtTranslateUTF16MessagetoLCPstring(const CHAR16_T* aUTF16Msg); typedef struct { const char* MexFileName; const char* TimeStamp; const char* buildDir; int32_T numFcns; int32_T numHistogramBins; } emlrtLocationLoggingFileInfoType; typedef struct { const char* FunctionName; int32_T FunctionID; int32_T numInstrPoints; } emlrtLocationLoggingFunctionInfoType; typedef struct { real_T NumberOfZeros; real_T NumberOfPositiveValues; real_T NumberOfNegativeValues; real_T TotalNumberOfValues; real_T SimSum; real_T HistogramOfPositiveValues[256]; real_T HistogramOfNegativeValues[256]; } emlrtLocationLoggingHistogramType; typedef struct { real_T SimMin; real_T SimMax; int32_T OverflowWraps; int32_T Saturations; boolean_T IsAlwaysInteger; emlrtLocationLoggingHistogramType* HistogramTable; } emlrtLocationLoggingDataType; typedef struct { int32_T MxInfoID; int32_T TextStart; int32_T TextLength; int16_T Reason; boolean_T MoreLocations; } emlrtLocationLoggingLocationType; /* * MATLAB INTERNAL USE ONLY :: Get LocationLogging Info */ EXTERN_C LIBEMLRT_API mxArray* emlrtLocationLoggingPullLog(const char* const MexFileName, boolean_T pullCompReportFromMexFunction); /* * MATLAB INTERNAL USE ONLY :: Save LocationLogging Info */ EXTERN_C LIBEMLRT_API void emlrtLocationLoggingPushLog( const emlrtLocationLoggingFileInfoType* const fileInfo, const emlrtLocationLoggingFunctionInfoType* const functionInfoTable, const emlrtLocationLoggingDataType* const dataTables, const emlrtLocationLoggingLocationType* const locationTables, const uint8_T* serializedReport, size_t sizeofSerializedReport, const int32_T* numFieldsTables, const char** fieldNamesTables); /* * MATLAB INTERNAL USE ONLY :: Save LocationLogging Info */ EXTERN_C LIBEMLRT_API void emlrtLocationLoggingPushLogR2017a( const emlrtLocationLoggingFileInfoType* const fileInfo, const emlrtLocationLoggingFunctionInfoType* const functionInfoTable, const emlrtLocationLoggingDataType* const dataTables, const emlrtLocationLoggingLocationType* const locationTables, const int32_T* numFieldsTables, const char** fieldNamesTables, const char* serializedReport[], size_t sizeofSerializedReport); /* * MATLAB INTERNAL USE ONLY :: Clear LocationLogging Info */ EXTERN_C LIBEMLRT_API boolean_T emlrtLocationLoggingClearLog(const char* const MexFileName); /* * MATLAB INTERNAL USE ONLY :: List entries in LocationLogging Info */ EXTERN_C LIBEMLRT_API mxArray* emlrtLocationLoggingListLogs(void); /* * MATLAB INTERNAL USE ONLY :: Add instrumentation results to FPT Repository */ EXTERN_C LIBEMLRT_API void addResultsToFPTRepository(const char* const blkSID); /* * MATLAB INTERNAL USE ONLY :: Initialize a runtime stack */ EXTERN_C LIBEMLRT_API void emlrtEnterRtStackR2012b(emlrtCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Terminate a runtime stack */ EXTERN_C LIBEMLRT_API void emlrtLeaveRtStackR2012b(emlrtCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Push to runtime stack */ EXTERN_C LIBEMLRT_API void emlrtPushRtStackR2012b(const struct emlrtRSInfo* aRSInfo, emlrtCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Pop from runtime stack */ EXTERN_C LIBEMLRT_API void emlrtPopRtStackR2012b(const struct emlrtRSInfo* aRSInfo, emlrtCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Get the address of the Ctrl-C flag. */ EXTERN_C LIBEMLRT_API const volatile char* emlrtGetBreakCheckFlagAddressR2012b(void); /* * MATLAB INTERNAL USE ONLY :: Check for Ctrl+C (break) */ EXTERN_C LIBEMLRT_API void emlrtBreakCheckR2012b(emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Equality check for 1-D sizes */ EXTERN_C LIBEMLRT_API void emlrtSizeEqCheck1DR2012b(int32_T dim1, int32_T dim2, emlrtECInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Equality check error for size vectors */ EXTERN_C LIBEMLRT_API void emlrtSizeEqCheckNDErrorR2021b(const int32_T* dims1, const int32_T* dims2, emlrtECInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Equality check for size vectors */ EXTERN_C LIBEMLRT_API void emlrtSizeEqCheckNDR2012b(const int32_T* dims1, const int32_T* dims2, emlrtECInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: equality check */ EXTERN_C LIBEMLRT_API void emlrtDimSizeEqCheckR2012b(int32_T dim1, int32_T dim2, emlrtECInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: greater than or equal to check */ EXTERN_C LIBEMLRT_API void emlrtDimSizeGeqCheckR2012b(int32_T dim1, int32_T dim2, emlrtECInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: equality or singleton check */ EXTERN_C LIBEMLRT_API void emlrtDimSizeImpxCheckR2021b(int32_T dim1, int32_T dim2, emlrtECInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Check size compatibility for A(I1,..IN) = B assignment in MATLAB. */ EXTERN_C LIBEMLRT_API void emlrtSubAssignSizeCheckR2012b(const int32_T* dims1, int32_T nDims1, const int32_T* dims2, int32_T nDims2, emlrtECInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Check size compatibility for A(I) = B assignment in MATLAB. */ EXTERN_C LIBEMLRT_API void emlrtSubAssignSizeCheck1dR2017a(int32_T dim1, int32_T dim2, emlrtECInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Allocate thread-local storage. */ EXTERN_C LIBEMLRT_API void* emlrtAllocTLS(emlrtConstCTX aMaster, int32_T aTeamTID); /* * MATLAB INTERNAL USE ONLY :: Allocate thread local storage for a parallel region. */ EXTERN_C LIBEMLRT_API int32_T emlrtAllocRegionTLSs(emlrtCTX aTLS, boolean_T aInParallelRegion, int32_T aMaxThreads, int32_T aNumThreads); /* * MATLAB INTERNAL USE ONLY :: Allocate the root thread-local storage. */ EXTERN_C LIBEMLRT_API void emlrtUpdateCTX(emlrtConstCTX emlrtCtx, struct emlrtContext* aContext); /* * MATLAB INTERNAL USE ONLY :: Allocate the root thread-local storage. */ EXTERN_C LIBEMLRT_API void emlrtCreateRootTLSR2021a(emlrtCTX* aRootTLS, struct emlrtContext* aContext, EmlrtLockerFunction aLockerFunction, int32_T aNumProcs, void* aExceptionBridge); /* * MATLAB INTERNAL USE ONLY :: Deallocate the root thread-local storage. */ EXTERN_C LIBEMLRT_API void emlrtDestroyRootTLS(emlrtCTX* aRootTLS); EXTERN_C LIBEMLRT_API void emlrtSetIsInDestructor(emlrtCTX aTLS, bool aValue); EXTERN_C LIBEMLRT_API void emlrtShouldCleanupOnError(emlrtCTX aTLS, bool aValue); EXTERN_C LIBEMLRT_API void emlrtCleanupOnException(emlrtCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Set Jit Simulation Mode. */ EXTERN_C LIBEMLRT_API void emlrtSetSimThruJIT(emlrtCTX aTLS, boolean_T aSimThruJIT); EXTERN_C LIBEMLRT_API char* emlrtExtractMessageId2015b(emlrtConstCTX aTLS, const struct emlrtMsgIdentifier* aMsgId); /* * MATLAB INTERNAL USE ONLY :: Check the class of an mxArray */ EXTERN_C LIBEMLRT_API void emlrtCheckClass(const char* msgName, const mxArray* pa, const char* className); /* * MATLAB INTERNAL USE ONLY :: Check the class of an mxArray pa to be exactly aClassName, otherwise * error out using aMsgId and aTLS. */ EXTERN_C LIBEMLRT_API void emlrtCheckMcosClass2017a(emlrtConstCTX aTLS, const emlrtMsgIdentifier* aMsgId, const mxArray* pa, const char* aClassName); /* * MATLAB INTERNAL USE ONLY :: Check the contents of two mxArrays to be equal. */ EXTERN_C LIBEMLRT_API void emlrtCheckCtMxArray2018b(emlrtConstCTX aTLS, const emlrtMsgIdentifier* aMsgId, const mxArray* rtArray, const mxArray* ctArray); /* * MATLAB INTERNAL USE ONLY :: Check the size, class and complexness of an mxArray */ EXTERN_C LIBEMLRT_API void emlrtCheckBuiltInR2012b(emlrtConstCTX aTLS, const struct emlrtMsgIdentifier* aMsgId, const mxArray* pa, const char* className, boolean_T complex, uint32_T nDims, const void* pDims); /* * MATLAB INTERNAL USE ONLY :: Check the size, class and complexness of a variable-size mxArray */ EXTERN_C LIBEMLRT_API void emlrtCheckVsBuiltInR2012b(emlrtConstCTX aTLS, const struct emlrtMsgIdentifier* aMsgId, const mxArray* pa, const char* className, boolean_T complex, uint32_T nDims, const void* pDims, const boolean_T* aDynamic, int32_T* aOutSizes); /* * MATLAB INTERNAL USE ONLY :: Check the type of a FI mxArray */ EXTERN_C LIBEMLRT_API void emlrtCheckFiR2012b(emlrtConstCTX aTLS, const struct emlrtMsgIdentifier* aMsgId, const mxArray* aFi, boolean_T aComplex, uint32_T aNDims, const void* aVDims, const mxArray* aFimath, const mxArray* aNumericType); /* * MATLAB INTERNAL USE ONLY :: Check the type of a variable-size FI mxArray */ EXTERN_C LIBEMLRT_API void emlrtCheckVsFiR2012b(emlrtConstCTX aTLS, const struct emlrtMsgIdentifier* aMsgId, const mxArray* aFi, boolean_T aComplex, uint32_T aNDims, const void* aVDims, const boolean_T* aDynamic, const mxArray* aFimath, const mxArray* aNumericType); /* * MATLAB INTERNAL USE ONLY :: Check the type of a static-size struct mxArray */ EXTERN_C LIBEMLRT_API void emlrtCheckStructR2012b(emlrtConstCTX aTLS, const emlrtMsgIdentifier* aMsgId, const mxArray* s, int32_T nFields, const char** fldNames, uint32_T nDims, const void* pDims); /* * MATLAB INTERNAL USE ONLY :: Check the type of a variable-size struct mxArray */ EXTERN_C LIBEMLRT_API void emlrtCheckVsStructR2012b(emlrtConstCTX aTLS, const struct emlrtMsgIdentifier* aMsgId, const mxArray* s, int32_T nFields, const char** fldNames, uint32_T nDims, const void* pDims, const boolean_T* aDynamic, int32_T* aOutSizes); /* * MATLAB INTERNAL USE ONLY :: Check the checksum of an mxArray */ EXTERN_C LIBEMLRT_API void emlrtCheckArrayChecksumR2018b(emlrtConstCTX, mxArray const*, boolean_T globalVar, int const*, const char**, uint32_T const*); /* * MATLAB INTERNAL USE ONLY :: Check the type of a static-size struct mxArray */ EXTERN_C LIBEMLRT_API void emlrtCheckEnumR2012b(emlrtConstCTX aTLS, const char* enumName, int32_T nEnumElements, const char** enumNames, const int32_T* enumValues); /* * MATLAB INTERNAL USE ONLY :: Import a character array. */ EXTERN_C LIBEMLRT_API void emlrtImportCharArrayR2015b(emlrtConstCTX aTLS, const mxArray* aSrc, char_T* aDst, int32_T aNumel); /* * MATLAB INTERNAL USE ONLY :: Import a character. */ EXTERN_C LIBEMLRT_API void emlrtImportCharR2015b(emlrtConstCTX aTLS, const mxArray* aSrc, char_T* aDst); /* * MATLAB INTERNAL USE ONLY :: Set the actual size of a variable-size array */ EXTERN_C LIBEMLRT_API void emlrtSetVsSizesR2008b(const mxArray* pa, uint32_T nDimsMax, int32_T* aOutSizes); /* * MATLAB INTERNAL USE ONLY :: Import an mxArray */ EXTERN_C LIBEMLRT_API void emlrtImportArrayR2015b(emlrtConstCTX aTLS, const mxArray* aIn, void* aOutData, int32_T aElementSize, boolean_T aComplex); /* * MATLAB INTERNAL USE ONLY :: Import an mxArray */ EXTERN_C LIBEMLRT_API void emlrtImportArrayR2015b_SameComplex(emlrtConstCTX aTLS, const mxArray* aIn, void* aOutData, int32_T aElementSize); /* * MATLAB INTERNAL USE ONLY :: Import a FI mxArray */ EXTERN_C LIBEMLRT_API void emlrtImportVsFiArrayR2011b(const mxArray* aFiMx, const mxArray* aIntMx, void* aOutData, int32_T aElementSize, boolean_T aComplex, uint32_T nDimsMax, int32_T* aOutSizes); /* * MATLAB INTERNAL USE ONLY :: Set the actual sizes of a dynamic FI array */ EXTERN_C LIBEMLRT_API void emlrtSetVsFiSizes(const mxArray* aFi, uint32_T nDimsExpected, int32_T* aOutSizes); /* * MATLAB INTERNAL USE ONLY :: Get double uniform random values in (0,1) */ EXTERN_C LIBEMLRT_API void emlrtRandu(real_T* const aRanduBuffer, const int32_T aNumel); /* * MATLAB INTERNAL USE ONLY :: Get double normal random values */ EXTERN_C LIBEMLRT_API void emlrtRandn(real_T* const aRandnBuffer, const int32_T aNumel); /* * MATLAB INTERNAL USE ONLY :: Check the type of a static-sized cell mxArray */ EXTERN_C LIBEMLRT_API void emlrtCheckCell(emlrtConstCTX aTLS, const emlrtMsgIdentifier* aMsgId, const mxArray* s, uint32_T nDims, const void* pDims, const boolean_T* aDynamic); /* * MATLAB INTERNAL USE ONLY :: Check the type of a variable-sized cell mxArray * and assign the size of the mxArray to aOutSizes */ EXTERN_C LIBEMLRT_API void emlrtCheckVsCell(emlrtConstCTX aTLS, const struct emlrtMsgIdentifier* aMsgId, const mxArray* s, uint32_T nDims, const void* pDims, const boolean_T* aDynamic, int32_T* aOutSizes); /* * MATLAB INTERNAL USE ONLY :: Check a cell mxArray with unassigned base type */ EXTERN_C LIBEMLRT_API void emlrtCheckCellWithUnassignedBase(emlrtConstCTX aTLS, const struct emlrtMsgIdentifier* aMsgId, const mxArray* pa); /* * MATLAB INTERNAL USE ONLY :: Get the library path of a function pointer */ EXTERN_C LIBEMLRT_API const char* emlrtGetLibraryPath(const void* pFcn); /* * MATLAB INTERNAL USE ONLY :: emlrt strlen function */ EXTERN_C LIBEMLRT_API size_t emlrtStrlen(const char*); /* * MATLAB INTERNAL USE ONLY :: FFTW MEX Wrapper */ EXTERN_C LIBEMLRT_API void* emlrtFFTWMalloc(size_t aSize); EXTERN_C LIBEMLRT_API void emlrtFFTWFree(void* data); /* * MATLAB INTERNAL USE ONLY :: Double 1D complex to complex FFT, this function assumes in and out to * be interleaved complex. */ EXTERN_C LIBEMLRT_API void emlrtFFTW_1D_C2C(const real_T* in, real_T* out, int32_T stride, int32_T fftLen, int32_T ldx, int32_T numFFT, int32_T direction); EXTERN_C LIBEMLRT_API void emlrtFFTW_1D_R2C(const real_T* in, real_T* out, int32_T stride, int32_T fftLen, int32_T ldx, int32_T numFFT, int32_T direction); EXTERN_C LIBEMLRT_API void emlrtFFTW_1D_C2R(const real_T* in, real_T* out, int32_T stride, int32_T fftLen, int32_T ldx, int32_T numFFT, int32_T direction); /* * MATLAB INTERNAL USE ONLY :: Float 1D complex to complex FFT, this function assumes in and out to * be interleaved complex. */ EXTERN_C LIBEMLRT_API void emlrtFFTWF_1D_C2C(const real32_T* in, real32_T* out, int32_T stride, int32_T fftLen, int32_T ldx, int32_T numFFT, int32_T direction); EXTERN_C LIBEMLRT_API void emlrtFFTWF_1D_R2C(const real32_T* in, real32_T* out, int32_T stride, int32_T fftLen, int32_T ldx, int32_T numFFT, int32_T direction); EXTERN_C LIBEMLRT_API void emlrtFFTWF_1D_C2R(const real32_T* in, real32_T* out, int32_T stride, int32_T fftLen, int32_T ldx, int32_T numFFT, int32_T direction); /* * MATLAB INTERNAL USE ONLY :: Setter and getter for FFTW plan method. */ EXTERN_C LIBEMLRT_API const char* emlrtFFTWGetPlanMethod(void); EXTERN_C LIBEMLRT_API void emlrtFFTWSetPlanMethod(const char* method); /* * MATLAB INTERNAL USE ONLY :: Double FFTW plan import/export/delete. */ EXTERN_C LIBEMLRT_API char* emlrtFFTWExportDoublePlan(void); EXTERN_C LIBEMLRT_API void emlrtFFTWImportDoublePlan(const char* aPlanStr); EXTERN_C LIBEMLRT_API void emlrtFFTWForgetDoublePlan(void); /* * MATLAB INTERNAL USE ONLY :: Double FFTW plan import/export/delete. */ EXTERN_C LIBEMLRT_API char* emlrtFFTWExportSinglePlan(void); EXTERN_C LIBEMLRT_API void emlrtFFTWImportSinglePlan(const char* aPlanStr); EXTERN_C LIBEMLRT_API void emlrtFFTWForgetSinglePlan(void); /* * MATLAB INTERNAL USE ONLY :: Force FFTW to run with single thread or not. */ EXTERN_C LIBEMLRT_API void emlrtFFTWSetNumThreads(int32_T numThreads); /* * MATLAB INTERNAL USE ONLY :: Check LXE profiler status */ EXTERN_C LIBEMLRT_API void emlrtCheckProfilerStatus(); #ifndef __cplusplus /* * MATLAB INTERNAL USE ONLY :: MEX Profiling Function Entry */ EXTERN_C LIBEMLRT_API void emlrtMEXProfilingFunctionEntry(const char* fcnUniqKey, boolean_T isMexOutdated); /* * MATLAB INTERNAL USE ONLY :: MEX Profiling Function Exit */ EXTERN_C LIBEMLRT_API void emlrtMEXProfilingFunctionExit(boolean_T isMexOutdated); #else // Need a sentinel class to make sure call stack is correct during stack unwinding struct LIBEMLRT_API emlrtProfilerSentinel { emlrtProfilerSentinel(); ~emlrtProfilerSentinel(); bool Initialized; bool AlreadyExit; private: emlrtProfilerSentinel& operator=(const emlrtProfilerSentinel&); emlrtProfilerSentinel(const emlrtProfilerSentinel&); }; /* * MATLAB INTERNAL USE ONLY :: MEX Profiling Function Entry */ LIBEMLRT_API void emlrtMEXProfilingFunctionEntryCPP(const char* fcnUniqKey, boolean_T isMexOutdated, emlrtProfilerSentinel* aSentinel); /* * MATLAB INTERNAL USE ONLY :: MEX Profiling Function Exit */ LIBEMLRT_API void emlrtMEXProfilingFunctionExitCPP(emlrtProfilerSentinel* aSentinel); #endif /* * MATLAB INTERNAL USE ONLY :: MEX Profiling Unregister Function */ EXTERN_C LIBEMLRT_API void emlrtProfilerUnregisterMEXFcn(const char* fcnUniqKey, boolean_T isMexOutdated); /* * MATLAB INTERNAL USE ONLY :: MEX Profiling Register Function */ EXTERN_C LIBEMLRT_API void emlrtProfilerRegisterMEXFcn(const char* completeName, const char* aPath, const char* aFcnName, int32_T numLineNos, const int32_T* lineNos, boolean_T isMexOutdated); /* * MATLAB INTERNAL USE ONLY :: MEX Profiling Profile Statement */ EXTERN_C LIBEMLRT_API void emlrtMEXProfilingStatement(uint32_T aPoint, boolean_T isMexOutdated); /* * MATLAB INTERNAL USE ONLY :: MEX Profiling Check MEX File Outdated Function */ EXTERN_C LIBEMLRT_API boolean_T emlrtProfilerCheckMEXOutdated(void); /* * MATLAB INTERNAL USE ONLY :: Report a detected CUDA runtime error */ EXTERN_C LIBEMLRT_API void emlrtCUDAError(uint32_T errcode, const char* ename, const char* emsg, const emlrtRTEInfo* aInfo, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Report a detected CUDA runtime error as a warning * useful for capturing errors within destructors and throwing those as warnings, so that * MATLAB does not crash for MEX builds */ EXTERN_C LIBEMLRT_API void emlrtCUDAWarning(uint32_T errcode, const char* ename, const char* emsg, const emlrtRTEInfo* aInfo); /* * MATLAB INTERNAL USE ONLY :: Report a detected CUDA runtime error (light API) */ EXTERN_C LIBEMLRT_API void emlrtThinCUDAError(uint32_T errcode, const char* ename, const char* emsg, const char* paramname, emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Wrapper of several mxArray Apis */ EXTERN_C LIBEMLRT_API void* emlrtMxCalloc(size_t numEl, size_t elSize); EXTERN_C LIBEMLRT_API void emlrtMxFree(void* in); EXTERN_C LIBEMLRT_API mxArray* emlrtMxCreateString(const char* aStr); EXTERN_C LIBEMLRT_API mxArray* emlrtMxCreateDoubleScalar(double v); EXTERN_C LIBEMLRT_API void* emlrtMxGetData(const mxArray* aMxArray); EXTERN_C LIBEMLRT_API void emlrtMxSetData(mxArray* aMxArray, void* data); EXTERN_C LIBEMLRT_API real_T* emlrtMxGetPr(const mxArray* aMxArray); EXTERN_C LIBEMLRT_API boolean_T* emlrtMxGetLogicals(const mxArray* aMxArray); EXTERN_C LIBEMLRT_API void* emlrtMxGetImagData(const mxArray* aMxArray); EXTERN_C LIBEMLRT_API double* emlrtMxGetPi(const mxArray* aMxArray); EXTERN_C LIBEMLRT_API const mxArray* emlrtMexGetVariablePtr(const char* workspace, const char* varname); /* * MATLAB INTERNAL USE ONLY :: Initilize mxArray from multiword fixed point */ EXTERN_C LIBEMLRT_API void emlrtInitMultiwordFXP(const mxArray* mxArray, const void* inData, int32_T scaleFactor); EXTERN_C LIBEMLRT_API char* emlrtGetEnv(const char* aName); EXTERN_C LIBEMLRT_API void emlrtSetEnv(const char* aName, const char* aVal); EXTERN_C LIBEMLRT_API void emlrtCaptureInputs(const mxArray** data, int32_T numInputs, void* aFcnPtr); /* * MATLAB INTERNAL USE ONLY :: Create a numeric matrix mxGPUArray */ EXTERN_C LIBEMLRT_API mxGPUArray* emlrtGPUCreateNumericArray(const char* className, boolean_T nComplexFlag, int32_T ndim, const void* pdim); /* * MATLAB INTERNAL USE ONLY :: Get read only GPU device pointer from mxGpuArray */ EXTERN_C LIBEMLRT_API const void* emlrtGPUGetDataReadOnly(const mxGPUArray* inArray); /* * MATLAB INTERNAL USE ONLY :: Get GPU device pointer from mxGpuArray */ EXTERN_C LIBEMLRT_API void* emlrtGPUGetData(mxGPUArray* inArray); /* * MATLAB INTERNAL USE ONLY :: Get class name from class id */ EXTERN_C LIBEMLRT_API const char* emlrtClassIDToClassName(mxClassID classID); /* * MATLAB INTERNAL USE ONLY :: Marshall input mxArray and return mxGPUArray */ EXTERN_C LIBEMLRT_API const mxGPUArray* emlrt_marshallInGPU(emlrtConstCTX aTLS, const mxArray* inArray, const char* id, const char* className, boolean_T nComplexFlag, int32_T ndim, const void* pdim, boolean_T marshallByRef); /* * MATLAB INTERNAL USE ONLY :: Marshall input mxArray and return mxGPUArray */ EXTERN_C LIBEMLRT_API const mxGPUArray* emlrt_marshallInGPUVardim(emlrtConstCTX aTLS, const mxArray* inArray, const char* id, const char* className, boolean_T nComplexFlag, int32_T ndim, const void* pdim, boolean_T marshallByRef, const boolean_T* aDynamic, int32_T* aOutSizes); /* * MATLAB INTERNAL USE ONLY :: Marshall output mxGPUArray and return mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrt_marshallOutGPU(const mxGPUArray* inArray); /* * MATLAB INTERNAL USE ONLY :: Marshall output mxGPUArray and return mxArray */ EXTERN_C LIBEMLRT_API const mxArray* emlrt_marshallOutGPUVardim(mxGPUArray* const inArray, const int32_T aNDims, const int32_T* aOutSizes); /* * MATLAB INTERNAL USE ONLY :: Destroy GPUArray */ EXTERN_C LIBEMLRT_API void emlrtDestroyGPUArray(const mxGPUArray* inArray); /* * MATLAB INTERNAL USE ONLY :: Deep copy of input to protect it when modified */ EXTERN_C LIBEMLRT_API mxArray* emlrtProtectGPUArray(const mxArray* inArray); /* * MATLAB INTERNAL USE ONLY :: Deep copy of mxGPUArray */ EXTERN_C LIBEMLRT_API mxGPUArray* emlrtGPUCopyGPUArray(const mxGPUArray* inArray); /* * MATLAB INTERNAL USE ONLY :: Load gpu library */ EXTERN_C LIBEMLRT_API void emlrtInitGPU(emlrtConstCTX aTLS); /* * MATLAB INTERNAL USE ONLY :: Exit Time Cleanup */ EXTERN_C LIBEMLRT_API void emlrtExitTimeCleanup(struct emlrtContext*); typedef struct emlrtTimespec { double tv_sec; double tv_nsec; } emlrtTimespec; /* * MATLAB INTERNAL USE ONLY :: Get time using monotonic clock */ EXTERN_C LIBEMLRT_API int emlrtClockGettimeMonotonic(emlrtTimespec*); typedef struct emlrtStructTm { double tm_nsec; double tm_sec; double tm_min; double tm_hour; double tm_mday; double tm_mon; double tm_year; boolean_T tm_isdst; } emlrtStructTm; /* * MATLAB INTERNAL USE ONLY :: Get wallclock time */ EXTERN_C LIBEMLRT_API void emlrtWallclock(emlrtStructTm* aStructTm); #if defined(_WIN32) || defined(WIN32) /* * MATLAB INTERNAL USE ONLY :: Wrapper for nanosleep */ EXTERN_C LIBEMLRT_API int emlrtSleepWin64(uint32_T aMilliSeconds); #else /* * MATLAB INTERNAL USE ONLY :: Wrapper for nanosleep */ EXTERN_C LIBEMLRT_API int emlrtNanosleep(const emlrtTimespec*); #endif /* defined(_WIN32) || defined(WIN32) */ /* * MATLAB INTERNAL USE ONLY :: Sleep for some duration */ EXTERN_C LIBEMLRT_API int emlrtSleep(const emlrtTimespec* aEMLRTTimespec); /* * MATLAB INTERNAL USE ONLY :: Pause for user input like pause() */ EXTERN_C LIBEMLRT_API void emlrtPauseForInput(void); EXTERN_C LIBEMLRT_API mxArray* emlrtMxCPUtoGPU(const mxArray* pa); EXTERN_C LIBEMLRT_API mxArray* emlrtMxGPUtoCPU(const mxArray* pa); /* * MATLAB INTERNAL USE ONLY :: Profiling instrumentation APIs */ EXTERN_C LIBEMLRT_API void emlrtProfilingEnterFunction(const char* function, uint32_T nBlocks, uint32_T staticSize, const char* filename, uint32_T line); #ifdef INT_TYPE_64_IS_SUPPORTED EXTERN_C LIBEMLRT_API void emlrtProfilingNode(uint64_T aSequenceId, uint64_T aNodeId, uint64_T aTypeSequenceId, const char* aSid); EXTERN_C LIBEMLRT_API void emlrtProfilingNamedNode(uint64_T aSequenceId, uint64_T aNodeId, uint64_T aTypeSequenceId, const char* aSid, const char* aName); EXTERN_C LIBEMLRT_API void emlrtProfilingType(uint64_T aTypeSequenceId, uint64_T aTypeClassId, uint64_T aTypeInstanceId, uint64_T aTypeSize, const char* aName); #endif EXTERN_C LIBEMLRT_API void emlrtProfilingExitFunction(void); EXTERN_C LIBEMLRT_API void emlrtProfilingStart(void); EXTERN_C LIBEMLRT_API void emlrtProfilingSave(void); EXTERN_C LIBEMLRT_API void emlrtProfilingFinish(void); EXTERN_C LIBEMLRT_API void emlrtProfilingClear(void); /* * MATLAB INTERNAL USE ONLY :: mxClassID for half mxArray. */ #ifndef mxHALF_CLASS #define mxHALF_CLASS ((mxClassID)(-2357)) #endif #endif /* emlrt_h */