1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
|
/* -----------------------------------------------------------------------------
* Scilab support runtime
* -----------------------------------------------------------------------------*/
/* Scilab version macro */
#include "version.h"
#define SWIG_SCILAB_VERSION (SCI_VERSION_MAJOR * 100) + (SCI_VERSION_MINOR * 10) + SCI_VERSION_MAINTENANCE
/* Scilab standard headers */
#ifdef __cplusplus
extern "C" {
#endif
#include "api_scilab.h"
#if SWIG_SCILAB_VERSION < 540
#define __USE_DEPRECATED_STACK_FUNCTIONS__
#include "stack-c.h"
#endif
#if SWIG_SCILAB_VERSION < 600
#include "MALLOC.h"
#endif
#include "Scierror.h"
#include "localization.h"
#include "freeArrayOfString.h"
#include <sci_gateway.h>
#include <mex.h>
#ifdef __cplusplus
}
#endif
/* Gateway signature */
#if SWIG_SCILAB_VERSION >= 600
#define SWIG_GatewayParameters char* fname, void *pvApiCtx
#define SWIG_GatewayArguments fname, pvApiCtx
#else
#define SWIG_GatewayParameters char* fname, unsigned long fname_len
#define SWIG_GatewayArguments fname, fname_len
#endif
/* Function name management functions */
#include <stdlib.h>
static char *SwigFuncName = NULL;
static char *SWIG_Scilab_GetFuncName(void) {
return SwigFuncName;
}
static void SWIG_Scilab_SetFuncName(char *funcName) {
if (SwigFuncName != NULL) {
free(SwigFuncName);
}
SwigFuncName = strdup(funcName);
}
/* Api context management functions */
#if SWIG_SCILAB_VERSION >= 600
static void *pvApiCtx = NULL;
static void SWIG_Scilab_SetApiContext(void *apiCtx) {
pvApiCtx = apiCtx;
}
#else
#define SWIG_Scilab_SetApiContext(apiCtx)
#endif
/* Argument management functions */
#if SWIG_SCILAB_VERSION >= 540
#define SWIG_CheckInputArgument(pvApiCtx, minInputArgument, maxInputArgument) CheckInputArgument(pvApiCtx, minInputArgument, maxInputArgument)
#define SWIG_CheckInputArgumentAtLeast(pvApiCtx, minInputArgument) CheckInputArgumentAtLeast(pvApiCtx, minInputArgument)
#define SWIG_CheckOutputArgument(pvApiCtx, minOutputArgument, maxOutputArgument) CheckOutputArgument(pvApiCtx, minOutputArgument, maxOutputArgument)
#define SWIG_NbInputArgument(pvApiCtx) nbInputArgument(pvApiCtx)
#define SWIG_AssignOutputArgument(pvApiCtx, outputArgumentPos, argumentPos) AssignOutputVariable(pvApiCtx, outputArgumentPos) = argumentPos
#else
#define SWIG_CheckInputArgument(pvApiCtx, minInputArgument, maxInputArgument) CheckRhs(minInputArgument, maxInputArgument)
#define SWIG_CheckInputArgumentAtLeast(pvApiCtx, minInputArgument) CheckRhs(minInputArgument, 256)
#define SWIG_CheckOutputArgument(pvApiCtx, minOutputArgument, maxOutputArgument) CheckLhs(minOutputArgument, maxOutputArgument)
#define SWIG_NbInputArgument(pvApiCtx) Rhs
#define SWIG_AssignOutputArgument(pvApiCtx, outputArgumentPos, argumentPos) LhsVar(outputArgumentPos) = argumentPos
#endif
typedef int SwigSciObject;
static int SwigOutputPosition = -1;
static int SWIG_Scilab_GetOutputPosition(void) {
return SwigOutputPosition;
}
static void SWIG_Scilab_SetOutputPosition(int outputPosition) {
SwigOutputPosition = outputPosition;
}
SWIGRUNTIME int
SWIG_Scilab_SetOutput(void *pvApiCtx, SwigSciObject output) {
int outputPosition = SWIG_Scilab_GetOutputPosition();
if (outputPosition < 0)
return SWIG_ERROR;
SWIG_AssignOutputArgument(pvApiCtx, outputPosition,
SWIG_NbInputArgument(pvApiCtx) + outputPosition);
return SWIG_OK;
}
/* Error functions */
#define SCILAB_API_ARGUMENT_ERROR 999
SWIGINTERN const char*
SWIG_Scilab_ErrorType(int code) {
switch(code) {
case SWIG_MemoryError:
return "MemoryError";
case SWIG_IOError:
return "IOError";
case SWIG_RuntimeError:
return "RuntimeError";
case SWIG_IndexError:
return "IndexError";
case SWIG_TypeError:
return "TypeError";
case SWIG_DivisionByZero:
return "ZeroDivisionError";
case SWIG_OverflowError:
return "OverflowError";
case SWIG_SyntaxError:
return "SyntaxError";
case SWIG_ValueError:
return "ValueError";
case SWIG_SystemError:
return "SystemError";
case SWIG_AttributeError:
return "AttributeError";
default:
return "RuntimeError";
}
}
#define SWIG_ErrorType(code) SWIG_Scilab_ErrorType(code)
#ifndef SWIG_SCILAB_ERROR
#define SWIG_SCILAB_ERROR 20000
#endif
SWIGINTERN void
SWIG_Scilab_Error(int code, const char *msg) {
Scierror(SWIG_SCILAB_ERROR - code, _("SWIG/Scilab: %s: %s\n"), SWIG_Scilab_ErrorType(code), msg);
}
#define SWIG_Error(code, msg) SWIG_Scilab_Error(code, msg)
#define SWIG_fail return SWIG_ERROR;
SWIGRUNTIME void
SWIG_Scilab_Raise_Ex(const char *obj, const char *type, swig_type_info *descriptor) {
if (type) {
if (obj)
Scierror(SWIG_SCILAB_ERROR, "SWIG/Scilab: Exception (%s) occured: %s\n", type, obj);
else
Scierror(SWIG_SCILAB_ERROR, "SWIG/Scilab: Exception (%s) occured.\n", type);
}
}
SWIGRUNTIME void
SWIG_Scilab_Raise(const int obj, const char *type, swig_type_info *descriptor) {
Scierror(SWIG_SCILAB_ERROR, "SWIG/Scilab: Exception (%s) occured.\n", type);
}
/* Module initialization */
static int swig_module_initialized = 0;
SWIGRUNTIME int
SWIG_Module_Initialized() {
return swig_module_initialized;
}
/* Pointer conversion functions */
SWIGRUNTIME swig_type_info *
SWIG_Scilab_TypeQuery(const char *name);
SWIGINTERN int
SwigScilabCheckPtr(void *pvApiCtx, int iVar, swig_type_info *descriptor, char *fname) {
SciErr sciErr;
int *piAddrVar = NULL;
int iType = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
if (iType == sci_mlist) {
int iItemCount = 0;
void *pvTypeinfo = NULL;
sciErr = getListItemNumber(pvApiCtx, piAddrVar, &iItemCount);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
if (iItemCount < 3) {
return SWIG_ERROR;
}
sciErr = getPointerInList(pvApiCtx, piAddrVar, 2, &pvTypeinfo);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
if (descriptor) {
swig_cast_info *cast = SWIG_TypeCheck(SWIG_TypeName((swig_type_info*)pvTypeinfo), descriptor);
return (cast != NULL);
}
else {
return SWIG_ERROR;
}
}
else {
return (iType == sci_pointer);
}
}
SWIGINTERN int
SwigScilabPtrToObject(void *pvApiCtx, int iVar, void **pvObj, swig_type_info *descriptor, int flags, char *fname) {
SciErr sciErr;
int *piAddrVar = NULL;
int iType = 0;
void *pvPtr = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
if (iType == sci_mlist) {
int iItemCount = 0;
void *pvTypeinfo = NULL;
sciErr = getListItemNumber(pvApiCtx, piAddrVar, &iItemCount);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
if (iItemCount < 3) {
return SWIG_ERROR;
}
sciErr = getPointerInList(pvApiCtx, piAddrVar, 2, &pvTypeinfo);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
sciErr = getPointerInList(pvApiCtx, piAddrVar, 3, &pvPtr);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
if (pvPtr) {
if (descriptor) {
swig_cast_info *cast = SWIG_TypeCheck(SWIG_TypeName((swig_type_info *)pvTypeinfo), descriptor);
if (cast) {
int newmemory = 0;
pvPtr = SWIG_TypeCast(cast, pvPtr, &newmemory);
// TODO newmemory
}
else {
return SWIG_ERROR;
}
}
}
}
else if (iType == sci_pointer) {
sciErr = getPointer(pvApiCtx, piAddrVar, &pvPtr);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
}
else {
return SWIG_ERROR;
}
if (pvObj) {
*pvObj = pvPtr;
return SWIG_OK;
}
else {
return SWIG_ERROR;
}
}
SWIGRUNTIMEINLINE int
SwigScilabPtrFromObject(void *pvApiCtx, int iVarOut, void *pvObj, swig_type_info *descriptor, int flags, const char *pstTypeName) {
SciErr sciErr;
if (descriptor) {
int *piMListAddr = NULL;
sciErr = createMList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, 3, &piMListAddr);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
if (pstTypeName == NULL) {
pstTypeName = SWIG_TypeName(descriptor);
}
sciErr = createMatrixOfStringInList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, piMListAddr, 1, 1, 1, &pstTypeName);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
sciErr = createPointerInList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, piMListAddr, 2, descriptor);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
sciErr = createPointerInList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, piMListAddr, 3, pvObj);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
}
else {
sciErr = createPointer(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, pvObj);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* Pointer argument conversions */
SWIGRUNTIME int
SWIG_Scilab_ConvertPacked(void *pvApiCtx, int iVar, void *ptr, int sz, swig_type_info *ty, char *fname) {
swig_cast_info *tc;
int *piAddrVar = NULL;
char *pstString = NULL;
char *pstStringPtr = NULL;
SciErr sciErr;
sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
if (getAllocatedSingleString(pvApiCtx, piAddrVar, &pstString)) {
return SWIG_ERROR;
}
/* Pointer values must start with leading underscore */
if (*pstString != '_') {
freeAllocatedSingleString(pstString);
return SWIG_ERROR;
}
pstStringPtr = pstString;
pstStringPtr++;
pstStringPtr = (char*)SWIG_UnpackData(pstStringPtr, ptr, sz);
if (ty) {
if (!pstStringPtr) {
freeAllocatedSingleString(pstString);
return SWIG_ERROR;
}
tc = SWIG_TypeCheck(pstStringPtr, ty);
if (!tc) {
freeAllocatedSingleString(pstString);
return SWIG_ERROR;
}
}
freeAllocatedSingleString(pstString);
return SWIG_OK;
}
SWIGRUNTIME int
SWIG_Scilab_NewMemberObj(void *pvApiCtx, int iVarOut, void *ptr, int sz, swig_type_info *type) {
char result[1024];
char *r = result;
if ((2*sz + 1 + strlen(type->name)) > 1000) {
return SWIG_ERROR;
}
*(r++) = '_';
r = SWIG_PackData(r, ptr, sz);
strcpy(r, type->name);
if (createSingleString(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, &result[0]))
return SWIG_ERROR;
return SWIG_OK;
}
/*
* Pointer utility functions
*/
#include <stdint.h>
#ifdef __cplusplus
extern "C"
#endif
int SWIG_this(SWIG_GatewayParameters) {
void *ptrValue = NULL;
if (SwigScilabPtrToObject(pvApiCtx, 1, &ptrValue, NULL, 0, fname) == SWIG_OK) {
SWIG_Scilab_SetOutputPosition(1);
return SWIG_Scilab_SetOutput(pvApiCtx,
createScalarDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + 1,
(double)(uintptr_t)ptrValue));
}
else {
Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The value is not a pointer.\n"), fname, 1);
return SWIG_ERROR;
}
}
#ifdef __cplusplus
extern "C"
#endif
int SWIG_ptr(SWIG_GatewayParameters) {
void *ptrValue = NULL;
double dValue = 0;
if (SwigScilabPtrToObject(pvApiCtx, 1, &ptrValue, NULL, 0, fname) == SWIG_OK) {
SWIG_Scilab_SetOutputPosition(1);
return SWIG_Scilab_SetOutput(pvApiCtx,
SwigScilabPtrFromObject(pvApiCtx, 1, ptrValue, NULL, 0, NULL));
}
else {
int *piAddr;
SciErr sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if(sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
if (getScalarDouble(pvApiCtx, piAddr, &dValue) == 0) {
if (dValue != (uintptr_t)dValue) {
Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a pointer.\n"), fname, 1);
return SWIG_ValueError;
}
if ((dValue < 0) || (dValue > ULONG_MAX)) {
Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a pointer.\n"), fname, 1);
return SWIG_OverflowError;
}
SWIG_Scilab_SetOutputPosition(1);
return SWIG_Scilab_SetOutput(pvApiCtx,
SwigScilabPtrFromObject(pvApiCtx, 1, (void *) (uintptr_t)dValue, NULL, 0, NULL));
}
else {
Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A pointer or a double expected.\n"), "SWIG_ptr", 1);
return SWIG_TypeError;
}
}
}
|
