bug 5292
[scilab.git] / scilab / modules / mexlib / includes / mex.h
1
2 /*
3  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
4  * Copyright (C) INRIA 
5  * Copyright (C) ENPC
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
12  *
13  */
14
15 #ifdef __cplusplus
16 extern "C" {
17 #endif
18
19 #ifndef SCI_MEX 
20 #define SCI_MEX 
21
22 #ifdef WIN32
23         #include <stddef.h> /*for LCC */
24 #endif
25
26 #include "stack-c.h"
27
28
29 typedef int Matrix;
30 typedef unsigned long int vraiptrst;
31 #ifndef __DEF_MXARRAY__
32 #define __DEF_MXARRAY__
33 typedef int mxArray;
34 typedef int Gatefunc (int nlhs,mxArray *plhs[],int nrhs,mxArray *prhs[]);
35 #endif
36
37 typedef int (*GatefuncH) (int nlhs,mxArray *plhs[],int nrhs,
38                                  mxArray *prhs[]);
39
40 typedef int (*FGatefuncH) (int *nlhs,mxArray *plhs[],int *nrhs,
41                                  mxArray *prhs[]);
42
43 typedef int (*Myinterfun) (char *, GatefuncH F);
44
45 typedef int (*GT) ();
46
47 #ifndef __DEF_TABLE_STRUCT__
48 #define __DEF_TABLE_STRUCT__
49 typedef struct table_struct {
50         Myinterfun f;    /** interface **/
51         GT F;     /** function **/
52         char *name;      /** its name **/
53 } GenericTable;
54 #endif
55
56 #define mxLOGICAL int
57 #define mxLogical int
58
59 #define REAL 0
60 #define COMPLEX 1
61
62 #ifndef NULL
63 #define NULL 0
64 #endif
65
66 #define mxCreateFull mxCreateDoubleMatrix
67
68 #ifndef __cplusplus
69         #ifndef bool
70                 #define bool int
71         #endif
72 #endif
73
74 #define mexGetMatrixPtr(name) mexGetArrayPtr(name, "caller")
75
76 #define mexGetArrayPtr(name,type) mexGetArray(name,type) 
77
78
79 void mexPrintf (char *fmt,...);
80
81 /** Put a matrix in Scilab Workspace */ 
82 #define mexPutFull(name,m,n,ptrM,tag) \
83   if ( ! C2F(cwritemat)(name,(c_local=m,&c_local),(c1_local=n,&c1_local),ptrM,strlen(name))) {  \
84       mexErrMsgTxt(_("mexPutFull failed\n"));return; }
85
86 /* prototypes */
87
88 void mexInfo (char *); 
89 int mexCheck (char *,int ); 
90 mxArray *mxCreateCharMatrixFromStrings (int m, const char **str);
91 mxArray *mxCreateString (const char *string);
92 mxArray *C2F(mxcreatestring)  (char *string, long int l);
93 mxArray *C2F(mxcreatefull)  (int *m, int *n, int *it);
94 mxArray *mxCreateCharArray (int ND, const int *size);
95
96 mxArray *mxCreateCellArray (int ND, const int *size);
97 mxArray *mxCreateCellMatrix (int m, int n);
98
99 mxArray *mxCreateStructArray (int ndim, const int *dims, int nfields, const char **field_names);
100 mxArray *mxCreateStructMatrix (int m, int n, int nfields, const char **field_names);
101
102
103 mxArray *mxGetCell (const mxArray *ptr, int index);
104
105 double C2F(mxgetscalar)  (mxArray *ptr);
106 double * C2F(mxgetpi)  (mxArray *ptr);
107 double * C2F(mxgetpr)  (mxArray *ptr);
108 double *mxGetPi (const mxArray *ptr);
109 double *mxGetPr (const mxArray *ptr);
110 double mxGetScalar (const mxArray *ptr);
111 double mxGetInf (void);
112 double mxGetNaN (void);
113 double mxGetEps (void);
114 bool mxIsNaN (double x);
115 bool mxIsInf (double x);
116 bool mxIsFinite (double x);
117 int *mxGetDimensions (const mxArray *ptr);
118 int mxCalcSingleSubscript (const mxArray *ptr, int nsubs, const int *subs);
119 int mxGetNumberOfElements (const mxArray *ptr);
120 int mxGetNumberOfDimensions(const mxArray *ptr);
121 int mxGetNumberOfFields(const mxArray *ptr);
122 void *mxGetData(const mxArray *ptr);
123 void *mxGetImagData(const mxArray *ptr);
124
125 void clear_mex(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs);
126
127 extern void errjump (int n);
128 int  C2F(mxgetm)  (mxArray *ptr);
129 int  C2F(mxgetn)  (mxArray *ptr);
130 int  C2F(mxgetstring)  (mxArray *ptr, char *str, int *strl);
131 int  C2F(mxiscomplex)  (mxArray *ptr);
132 int  C2F(mxisfull)  (mxArray *ptr);
133 int  C2F(mxisnumeric)  (mxArray *ptr);
134 int  C2F(mxissparse)  (mxArray *ptr);
135 int  C2F(mxisstring)  (mxArray *ptr);
136 int *mxGetIr (const mxArray *ptr);
137 int *mxGetJc (const mxArray *ptr);
138
139 /**
140  * TODO : comment
141  * @param type
142  * @param m
143  * @param n
144  * @param it
145  * @param lr
146  * @param ptr
147  * @param type_len
148  * @return
149 */
150 int C2F(createptr)  (char *type, int *m, int *n, int *it, int *lr, int *ptr, long int type_len);
151
152 /**
153  * TODO : comment
154  * @param m
155  * @param ptr
156  * @return
157 */
158 int C2F(createstkptr)  (int *m, vraiptrst *ptr);
159
160
161 /**
162  * TODO : comment
163  * @param nlhs
164  * @param plhs
165  * @param nrhs
166  * @param prhs
167  * @return
168 */
169 int C2F(endmex)  (int *nlhs, mxArray **plhs, int *nrhs, mxArray **prhs);
170
171
172 /**
173  * TODO : comment
174  * @param nlhs
175  * @param plhs
176  * @param nrhs
177  * @param prhs
178  * @return
179 */
180 int C2F(initmex)  (int *nlhs, mxArray **plhs, int *nrhs, mxArray **prhs);
181
182 int C2F(mexcallscilab)  (int *nlhs, mxArray **plhs, int *nrhs, mxArray **prhs, char *name, int namelen);
183 int C2F(mxcopyptrtoreal8)  (mxArray *ptr, double *y, int *n);
184 int C2F(mxcopyreal8toptr)  (double *y, mxArray *ptr, int *n);
185 int fortran_mex_gateway (char *fname, FGatefuncH F);
186 int mexAtExit (mxArray *ptr);
187 int mexCallSCILAB (int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name);
188 int mexCallMATLAB (int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name);
189 int mex_gateway (char *fname, GatefuncH F);
190 int mxGetElementSize (const mxArray *ptr);
191 int mxGetM (const mxArray *ptr);
192 int mxGetN (const mxArray *ptr);
193 int mxGetNzmax (const mxArray *ptr);
194 int mxGetString (const mxArray *ptr, char *str, int strl);
195 char *mxArrayToString (const mxArray *array_ptr);
196 bool mxIsComplex (const mxArray *ptr);
197 bool mxIsDouble (const mxArray *ptr);
198 bool mxIsSingle (const mxArray *ptr);
199 bool mxIsFull (const mxArray *ptr);
200 bool mxIsNumeric (const mxArray *ptr);
201 bool mxIsSparse (const mxArray *ptr);
202 bool mxIsLogical (const mxArray *ptr);
203 bool mexIsGloball (const mxArray *ptr);
204 void mxSetLogical (mxArray *ptr);
205 void mxClearLogical (mxArray *ptr);
206 bool mxIsString (const mxArray *ptr);
207 bool mxIsChar (const mxArray *ptr);
208 bool mxIsEmpty (const mxArray *ptr);
209 bool mxIsClass (const mxArray *ptr, const char *name);
210 bool mxIsCell (const mxArray *ptr);
211 bool mxIsStruct (const mxArray *ptr);
212
213 bool mxIsInt8(const mxArray *ptr);
214 bool mxIsInt16(const mxArray *ptr);
215 bool mxIsInt32(const mxArray *ptr);
216 bool mxIsUint8(const mxArray *ptr);
217 bool mxIsUint16(const mxArray *ptr);
218 bool mxIsUint32(const mxArray *ptr);
219
220 void mxSetM(mxArray *ptr, int m);
221 void mxSetN(mxArray *ptr, int n);
222 void mxSetJc(mxArray *array_ptr, int *jc_data);
223 void mxSetIr(mxArray *array_ptr, int *ir_data);
224 void mxSetNzmax(mxArray *array_ptr, int nzmax);
225 void mxSetCell(mxArray *pa, int i, mxArray *value);
226
227 mxArray *mexGetArray(char *name, char *workspace);
228
229 mxArray *mexGetVariable(const char *workspace, const char *name);
230 const mxArray *mexGetVariablePtr(const char *workspace, const char *name);
231
232 unsigned long int C2F(mxcalloc)(unsigned int *n, unsigned int *size);
233
234 void  C2F(mexprintf)(char *error_msg, int len);
235
236 void *mxCalloc(size_t n, size_t size);
237 void *mxMalloc(size_t nsize);
238
239 void *mxCalloc_m(unsigned int n, unsigned int size);
240 void *mxMalloc_m(unsigned int nsize);
241 void  mxFree_m(void *);
242
243 void C2F(mexerrmsgtxt)(char *error_msg, int len);
244 void C2F(mxfreematrix)(mxArray *ptr);
245 void mexErrMsgTxt(char *error_msg);
246 int  mexEvalString(char *name);
247 void mexWarnMsgTxt(char *error_msg);
248 void mexprint(char* fmt,...);
249 void mxFree(void *ptr);
250 void mxFreeMatrix(mxArray *ptr);
251 void mxDestroyArray(mxArray *ptr);
252 int mxGetFieldNumber(const mxArray *ptr, const char *string);
253 mxArray *mxGetField(const mxArray *pa, int i, const char *fieldname);
254 void  mxSetFieldByNumber(mxArray *array_ptr, int index, int field_number, mxArray *value);
255 void mxSetField (mxArray *pa, int i, const char *fieldname, mxArray *value);
256
257
258 mxArray *mxGetFieldByNumber(const mxArray *ptr, int index, int field_number);
259 const char *mxGetFieldNameByNumber(const mxArray *array_ptr, int field_number);
260 mxLOGICAL *mxGetLogicals (mxArray *array_ptr);
261
262
263 /**
264  * TODO : comment
265  * @param x
266  * @return
267 */
268 vraiptrst C2F(locptr)(void *x);
269
270 typedef enum {
271         mxCELL_CLASS = 1,
272         mxSTRUCT_CLASS,
273         mxOBJECT_CLASS,
274         mxCHAR_CLASS,
275         mxSPARSE_CLASS,
276         mxDOUBLE_CLASS,
277         mxSINGLE_CLASS,
278         mxINT8_CLASS,
279         mxUINT8_CLASS,
280         mxINT16_CLASS,
281         mxUINT16_CLASS,
282         mxINT32_CLASS,
283         mxUINT32_CLASS,
284         mxUNKNOWN_CLASS = 0
285 } mxClassID;
286
287 typedef enum { mxREAL, mxCOMPLEX } mxComplexity; 
288
289
290
291 mxClassID mxGetClassID(const mxArray *ptr);
292 const char *mxGetName(const mxArray *array_ptr);
293 void mxSetName( mxArray    *pa,    const char *s );
294 void mxSetPr(mxArray *array_ptr, double *pr);
295 void mxSetPi(mxArray *array_ptr, double *pi);
296 void mxSetData(mxArray *array_ptr, void *pr);
297 mxArray *mxCreateNumericArray(int ndim, const int *dims, mxClassID classid, mxComplexity flag);
298 mxArray *mxCreateNumericMatrix(int m, int n, mxClassID classid, int cmplx_flag);
299 int mxSetDimensions(mxArray *array_ptr, const int *dims, int ndim);
300 mxArray *mxCreateDoubleMatrix(int m, int n, mxComplexity it);
301 mxArray *mxCreateDoubleScalar(double value);
302 mxArray *mxCreateSparse(int m, int n, int nzmax, mxComplexity cmplx);
303 mxArray *mxDuplicateArray(const mxArray *ptr);
304
305 /* typedef uint16_T mxChar; */
306
307 /* typedef short int mxChar; */
308 typedef unsigned short mxChar;
309
310 #define INT8_T char
311 #define UINT8_T unsigned char
312 #define INT16_T short
313 #define UINT16_T unsigned short
314 #define INT32_T int
315 #define UINT32_T unsigned int
316 #define REAL32_T float
317
318
319 typedef INT8_T int8_T;
320 typedef UINT8_T uint8_T;
321 typedef INT16_T int16_T;
322 typedef UINT16_T uint16_T;
323 typedef INT32_T int32_T;
324 typedef UINT32_T uint32_T;
325 typedef REAL32_T real32_T;
326
327 #endif /* SCI_MEX  */
328
329 #ifdef __cplusplus
330 }
331 #endif
332
333 /* generic mexfunction name */
334 #ifdef __cplusplus
335 extern "C" {
336   void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]);
337 }
338 #endif