1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2015 - Scilab Enterprises - Antoine ELIAS
4 *
5 * Copyright (C) 2012 - 2016 - Scilab Enterprises
6 *
7 * This file is hereby licensed under the terms of the GNU GPL v2.0,
8 * pursuant to article 5.3.4 of the CeCILL v.2.1.
9 * This file was originally licensed under the terms of the CeCILL v2.1,
10 * and continues to be available under such terms.
11 * For more information, see the COPYING file which you should have received
12 * along with this program.
13 */
14
15 #include "gatewaystruct.hxx"
16 #include "int.hxx"
17
18 extern "C"
19 {
20 #include "api_scilab.h"
21 }
22
API_PROTO(getIntegerPrecision)23 int API_PROTO(getIntegerPrecision)(scilabEnv env, scilabVar var)
24 {
25 switch (((types::InternalType*)var)->getType())
26 {
27 case types::InternalType::ScilabInt8:
28 return SCI_INT8;
29 case types::InternalType::ScilabUInt8:
30 return SCI_UINT8;
31 case types::InternalType::ScilabInt16:
32 return SCI_INT16;
33 case types::InternalType::ScilabUInt16:
34 return SCI_UINT16;
35 case types::InternalType::ScilabInt32:
36 return SCI_INT32;
37 case types::InternalType::ScilabUInt32:
38 return SCI_UINT32;
39 case types::InternalType::ScilabInt64:
40 return SCI_INT64;
41 case types::InternalType::ScilabUInt64:
42 return SCI_UINT64;
43 default:
44 return 0;
45 }
46 }
47
API_PROTO(isInt8)48 int API_PROTO(isInt8)(scilabEnv env, scilabVar var)
49 {
50 return ((types::InternalType*)var)->isInt8() ? 1 : 0;
51 }
52
API_PROTO(isInt16)53 int API_PROTO(isInt16)(scilabEnv env, scilabVar var)
54 {
55 return ((types::InternalType*)var)->isInt16() ? 1 : 0;
56 }
57
API_PROTO(isInt32)58 int API_PROTO(isInt32)(scilabEnv env, scilabVar var)
59 {
60 return ((types::InternalType*)var)->isInt32() ? 1 : 0;
61 }
62
API_PROTO(isInt64)63 int API_PROTO(isInt64)(scilabEnv env, scilabVar var)
64 {
65 return ((types::InternalType*)var)->isInt64() ? 1 : 0;
66 }
67
API_PROTO(isUnsignedInt8)68 int API_PROTO(isUnsignedInt8)(scilabEnv env, scilabVar var)
69 {
70 return ((types::InternalType*)var)->isUInt8() ? 1 : 0;
71 }
72
API_PROTO(isUnsignedInt16)73 int API_PROTO(isUnsignedInt16)(scilabEnv env, scilabVar var)
74 {
75 return ((types::InternalType*)var)->isInt16() ? 1 : 0;
76 }
77
API_PROTO(isUnsignedInt32)78 int API_PROTO(isUnsignedInt32)(scilabEnv env, scilabVar var)
79 {
80 return ((types::InternalType*)var)->isUInt32() ? 1 : 0;
81 }
82
API_PROTO(isUnsignedInt64)83 int API_PROTO(isUnsignedInt64)(scilabEnv env, scilabVar var)
84 {
85 return ((types::InternalType*)var)->isUInt64() ? 1 : 0;
86 }
87
API_PROTO(createInteger8)88 scilabVar API_PROTO(createInteger8)(scilabEnv env, char val)
89 {
90 return (scilabVar)new types::Int8(val);
91 }
92
API_PROTO(createInteger16)93 scilabVar API_PROTO(createInteger16)(scilabEnv env, short val)
94 {
95 return (scilabVar)new types::Int16(val);
96 }
97
API_PROTO(createInteger32)98 scilabVar API_PROTO(createInteger32)(scilabEnv env, int val)
99 {
100 return (scilabVar)new types::Int32(val);
101 }
102
API_PROTO(createInteger64)103 scilabVar API_PROTO(createInteger64)(scilabEnv env, long long val)
104 {
105 return (scilabVar)new types::Int64(val);
106 }
107
API_PROTO(createUnsignedInteger8)108 scilabVar API_PROTO(createUnsignedInteger8)(scilabEnv env, unsigned char val)
109 {
110 return (scilabVar)new types::UInt8(val);
111 }
112
API_PROTO(createUnsignedInteger16)113 scilabVar API_PROTO(createUnsignedInteger16)(scilabEnv env, unsigned short val)
114 {
115 return (scilabVar)new types::UInt16(val);
116 }
117
API_PROTO(createUnsignedInteger32)118 scilabVar API_PROTO(createUnsignedInteger32)(scilabEnv env, unsigned int val)
119 {
120 return (scilabVar)new types::UInt32(val);
121 }
122
API_PROTO(createUnsignedInteger64)123 scilabVar API_PROTO(createUnsignedInteger64)(scilabEnv env, unsigned long long val)
124 {
125 return (scilabVar)new types::UInt64(val);
126 }
127
API_PROTO(createIntegerMatrix)128 scilabVar API_PROTO(createIntegerMatrix)(scilabEnv env, int prec, int dim, const int* dims)
129 {
130 switch (prec)
131 {
132 case SCI_INT8:
133 return scilab_createInteger8Matrix(env, dim, dims);
134 case SCI_INT16:
135 return scilab_createInteger16Matrix(env, dim, dims);
136 case SCI_INT32:
137 return scilab_createInteger32Matrix(env, dim, dims);
138 case SCI_INT64:
139 return scilab_createInteger64Matrix(env, dim, dims);
140 case SCI_UINT8:
141 return scilab_createUnsignedInteger8Matrix(env, dim, dims);
142 case SCI_UINT16:
143 return scilab_createUnsignedInteger16Matrix(env, dim, dims);
144 case SCI_UINT32:
145 return scilab_createUnsignedInteger32Matrix(env, dim, dims);
146 case SCI_UINT64:
147 return scilab_createUnsignedInteger64Matrix(env, dim, dims);
148 }
149
150 return NULL;
151 }
152
API_PROTO(createInteger8Matrix)153 scilabVar API_PROTO(createInteger8Matrix)(scilabEnv env, int dim, const int* dims)
154 {
155 #ifdef __API_SCILAB_SAFE__
156 if (dims == nullptr)
157 {
158 scilab_setInternalError(env, L"createIntegerMatrix8", _W("dims array cannot be NULL"));
159 return nullptr;
160 }
161
162 for (int i = 0; i < dim; ++i)
163 {
164 if (dims[i] < 0)
165 {
166 scilab_setInternalError(env, L"createIntegerMatrix8", _W("dimensions cannot be negative"));
167 return nullptr;
168 }
169 }
170 #endif
171
172 return (scilabVar)new types::Int8(dim, dims);
173 }
174
API_PROTO(createInteger16Matrix)175 scilabVar API_PROTO(createInteger16Matrix)(scilabEnv env, int dim, const int* dims)
176 {
177 #ifdef __API_SCILAB_SAFE__
178 if (dims == nullptr)
179 {
180 scilab_setInternalError(env, L"createIntegerMatrix16", _W("dims array cannot be NULL"));
181 return nullptr;
182 }
183
184 for (int i = 0; i < dim; ++i)
185 {
186 if (dims[i] < 0)
187 {
188 scilab_setInternalError(env, L"createIntegerMatrix16", _W("dimensions cannot be negative"));
189 return nullptr;
190 }
191 }
192 #endif
193
194 return (scilabVar)new types::Int16(dim, dims);
195 }
196
API_PROTO(createInteger32Matrix)197 scilabVar API_PROTO(createInteger32Matrix)(scilabEnv env, int dim, const int* dims)
198 {
199 #ifdef __API_SCILAB_SAFE__
200 if (dims == nullptr)
201 {
202 scilab_setInternalError(env, L"createIntegerMatrix32", _W("dims array cannot be NULL"));
203 return nullptr;
204 }
205
206 for (int i = 0; i < dim; ++i)
207 {
208 if (dims[i] < 0)
209 {
210 scilab_setInternalError(env, L"createIntegerMatrix32", _W("dimensions cannot be negative"));
211 return nullptr;
212 }
213 }
214 #endif
215
216 return (scilabVar)new types::Int32(dim, dims);
217 }
218
API_PROTO(createInteger64Matrix)219 scilabVar API_PROTO(createInteger64Matrix)(scilabEnv env, int dim, const int* dims)
220 {
221 #ifdef __API_SCILAB_SAFE__
222 if (dims == nullptr)
223 {
224 scilab_setInternalError(env, L"createIntegerMatrix64", _W("dims array cannot be NULL"));
225 return nullptr;
226 }
227
228 for (int i = 0; i < dim; ++i)
229 {
230 if (dims[i] < 0)
231 {
232 scilab_setInternalError(env, L"createIntegerMatrix64", _W("dimensions cannot be negative"));
233 return nullptr;
234 }
235 }
236 #endif
237
238 return (scilabVar)new types::Int64(dim, dims);
239 }
240
API_PROTO(createUnsignedInteger8Matrix)241 scilabVar API_PROTO(createUnsignedInteger8Matrix)(scilabEnv env, int dim, const int* dims)
242 {
243 #ifdef __API_SCILAB_SAFE__
244 if (dims == nullptr)
245 {
246 scilab_setInternalError(env, L"createUnsignedIntegerMatrix8", _W("dims array cannot be NULL"));
247 return nullptr;
248 }
249
250 for (int i = 0; i < dim; ++i)
251 {
252 if (dims[i] < 0)
253 {
254 scilab_setInternalError(env, L"createUnsignedIntegerMatrix8", _W("dimensions cannot be negative"));
255 return nullptr;
256 }
257 }
258 #endif
259
260 return (scilabVar)new types::UInt8(dim, dims);
261 }
262
API_PROTO(createUnsignedInteger16Matrix)263 scilabVar API_PROTO(createUnsignedInteger16Matrix)(scilabEnv env, int dim, const int* dims)
264 {
265 #ifdef __API_SCILAB_SAFE__
266 if (dims == nullptr)
267 {
268 scilab_setInternalError(env, L"createUnsignedIntegerMatrix16", _W("dims array cannot be NULL"));
269 return nullptr;
270 }
271
272 for (int i = 0; i < dim; ++i)
273 {
274 if (dims[i] < 0)
275 {
276 scilab_setInternalError(env, L"createUnsignedIntegerMatrix16", _W("dimensions cannot be negative"));
277 return nullptr;
278 }
279 }
280 #endif
281
282 return (scilabVar)new types::UInt16(dim, dims);
283 }
284
API_PROTO(createUnsignedInteger32Matrix)285 scilabVar API_PROTO(createUnsignedInteger32Matrix)(scilabEnv env, int dim, const int* dims)
286 {
287 #ifdef __API_SCILAB_SAFE__
288 if (dims == nullptr)
289 {
290 scilab_setInternalError(env, L"createUnsignedIntegerMatrix32", _W("dims array cannot be NULL"));
291 return nullptr;
292 }
293
294 for (int i = 0; i < dim; ++i)
295 {
296 if (dims[i] < 0)
297 {
298 scilab_setInternalError(env, L"createUnsignedIntegerMatrix32", _W("dimensions cannot be negative"));
299 return nullptr;
300 }
301 }
302 #endif
303
304 return (scilabVar)new types::UInt32(dim, dims);
305 }
306
API_PROTO(createUnsignedInteger64Matrix)307 scilabVar API_PROTO(createUnsignedInteger64Matrix)(scilabEnv env, int dim, const int* dims)
308 {
309 #ifdef __API_SCILAB_SAFE__
310 if (dims == nullptr)
311 {
312 scilab_setInternalError(env, L"createUnsignedIntegerMatrix64", _W("dims array cannot be NULL"));
313 return nullptr;
314 }
315
316 for (int i = 0; i < dim; ++i)
317 {
318 if (dims[i] < 0)
319 {
320 scilab_setInternalError(env, L"createUnsignedIntegerMatrix64", _W("dimensions cannot be negative"));
321 return nullptr;
322 }
323 }
324 #endif
325
326 return (scilabVar)new types::UInt64(dim, dims);
327 }
328
API_PROTO(createIntegerMatrix2d)329 scilabVar API_PROTO(createIntegerMatrix2d)(scilabEnv env, int prec, int row, int col)
330 {
331 int dims[2] = {row, col};
332 return scilab_createIntegerMatrix(env, prec, 2, dims);
333 }
334
API_PROTO(createInteger8Matrix2d)335 scilabVar API_PROTO(createInteger8Matrix2d)(scilabEnv env, int row, int col)
336 {
337 return scilab_createIntegerMatrix2d(env, SCI_INT8, row, col);
338 }
339
API_PROTO(createInteger16Matrix2d)340 scilabVar API_PROTO(createInteger16Matrix2d)(scilabEnv env, int row, int col)
341 {
342 return scilab_createIntegerMatrix2d(env, SCI_INT16, row, col);
343 }
344
API_PROTO(createInteger32Matrix2d)345 scilabVar API_PROTO(createInteger32Matrix2d)(scilabEnv env, int row, int col)
346 {
347 return scilab_createIntegerMatrix2d(env, SCI_INT32, row, col);
348 }
349
API_PROTO(createInteger64Matrix2d)350 scilabVar API_PROTO(createInteger64Matrix2d)(scilabEnv env, int row, int col)
351 {
352 return scilab_createIntegerMatrix2d(env, SCI_INT64, row, col);
353 }
354
API_PROTO(createUnsignedInteger8Matrix2d)355 scilabVar API_PROTO(createUnsignedInteger8Matrix2d)(scilabEnv env, int row, int col)
356 {
357 return scilab_createIntegerMatrix2d(env, SCI_UINT8, row, col);
358 }
359
API_PROTO(createUnsignedInteger16Matrix2d)360 scilabVar API_PROTO(createUnsignedInteger16Matrix2d)(scilabEnv env, int row, int col)
361 {
362 return scilab_createIntegerMatrix2d(env, SCI_UINT16, row, col);
363 }
364
API_PROTO(createUnsignedInteger32Matrix2d)365 scilabVar API_PROTO(createUnsignedInteger32Matrix2d)(scilabEnv env, int row, int col)
366 {
367 return scilab_createIntegerMatrix2d(env, SCI_UINT32, row, col);
368 }
369
API_PROTO(createUnsignedInteger64Matrix2d)370 scilabVar API_PROTO(createUnsignedInteger64Matrix2d)(scilabEnv env, int row, int col)
371 {
372 return scilab_createIntegerMatrix2d(env, SCI_UINT64, row, col);
373 }
374
API_PROTO(getInteger8)375 scilabStatus API_PROTO(getInteger8)(scilabEnv env, scilabVar var, char* val)
376 {
377 types::Int8* i = (types::Int8*)var;
378 #ifdef __API_SCILAB_SAFE__
379 if (i->isInt8() == false || i->isScalar() == false)
380 {
381 scilab_setInternalError(env, L"getInteger8", _W("var must be a scalar int8 variable"));
382 return STATUS_ERROR;
383 }
384 #endif
385 *val = i->get()[0];
386 return STATUS_OK;
387 }
388
API_PROTO(getInteger16)389 scilabStatus API_PROTO(getInteger16)(scilabEnv env, scilabVar var, short* val)
390 {
391 types::Int16* i = (types::Int16*)var;
392 #ifdef __API_SCILAB_SAFE__
393 if (i->isInt16() == false || i->isScalar() == false)
394 {
395 scilab_setInternalError(env, L"getInteger16", _W("var must be a scalar int16 variable"));
396 return STATUS_ERROR;
397 }
398 #endif
399 *val = i->get()[0];
400 return STATUS_OK;
401 }
402
API_PROTO(getInteger32)403 scilabStatus API_PROTO(getInteger32)(scilabEnv env, scilabVar var, int* val)
404 {
405 types::Int32* i = (types::Int32*)var;
406 #ifdef __API_SCILAB_SAFE__
407 if (i->isInt32() == false || i->isScalar() == false)
408 {
409 scilab_setInternalError(env, L"getInteger32", _W("var must be a scalar int32 variable"));
410 return STATUS_ERROR;
411 }
412 #endif
413 *val = i->get()[0];
414 return STATUS_OK;
415 }
416
API_PROTO(getInteger64)417 scilabStatus API_PROTO(getInteger64)(scilabEnv env, scilabVar var, long long* val)
418 {
419 types::Int64* i = (types::Int64*)var;
420 #ifdef __API_SCILAB_SAFE__
421 if (i->isInt64() == false || i->isScalar() == false)
422 {
423 scilab_setInternalError(env, L"getInteger64", _W("var must be a scalar int64 variable"));
424 return STATUS_ERROR;
425 }
426 #endif
427 *val = i->get()[0];
428 return STATUS_OK;
429 }
430
API_PROTO(getUnsignedInteger8)431 scilabStatus API_PROTO(getUnsignedInteger8)(scilabEnv env, scilabVar var, unsigned char* val)
432 {
433 types::UInt8* i = (types::UInt8*)var;
434 #ifdef __API_SCILAB_SAFE__
435 if (i->isUInt8() == false || i->isScalar() == false)
436 {
437 scilab_setInternalError(env, L"getUnsignedInteger8", _W("var must be a scalar uint8 variable"));
438 return STATUS_ERROR;
439 }
440 #endif
441 *val = i->get()[0];
442 return STATUS_OK;
443 }
444
API_PROTO(getUnsignedInteger16)445 scilabStatus API_PROTO(getUnsignedInteger16)(scilabEnv env, scilabVar var, unsigned short* val)
446 {
447 types::UInt16* i = (types::UInt16*)var;
448 #ifdef __API_SCILAB_SAFE__
449 if (i->isUInt16() == false || i->isScalar() == false)
450 {
451 scilab_setInternalError(env, L"getUnsignedInteger16", _W("var must be a scalar uint16 variable"));
452 return STATUS_ERROR;
453 }
454 #endif
455 *val = i->get()[0];
456 return STATUS_OK;
457 }
458
API_PROTO(getUnsignedInteger32)459 scilabStatus API_PROTO(getUnsignedInteger32)(scilabEnv env, scilabVar var, unsigned int* val)
460 {
461 types::UInt32* i = (types::UInt32*)var;
462 #ifdef __API_SCILAB_SAFE__
463 if (i->isUInt32() == false || i->isScalar() == false)
464 {
465 scilab_setInternalError(env, L"getUnsignedInteger32", _W("var must be a scalar uint32 variable"));
466 return STATUS_ERROR;
467 }
468 #endif
469 *val = i->get()[0];
470 return STATUS_OK;
471 }
472
API_PROTO(getUnsignedInteger64)473 scilabStatus API_PROTO(getUnsignedInteger64)(scilabEnv env, scilabVar var, unsigned long long* val)
474 {
475 types::UInt64* i = (types::UInt64*)var;
476 #ifdef __API_SCILAB_SAFE__
477 if (i->isUInt64() == false || i->isScalar() == false)
478 {
479 scilab_setInternalError(env, L"getUnsignedInteger64", _W("var must be a scalar uint64 variable"));
480 return STATUS_ERROR;
481 }
482 #endif
483 *val = i->get()[0];
484 return STATUS_OK;
485 }
486
API_PROTO(getIntegerArray)487 scilabStatus API_PROTO(getIntegerArray)(scilabEnv env, scilabVar var, void** vals)
488 {
489 switch (((types::InternalType*)var)->getType())
490 {
491 case types::InternalType::ScilabInt8:
492 return scilab_getInteger8Array(env, var, (char**)vals);
493 case types::InternalType::ScilabInt16:
494 return scilab_getInteger16Array(env, var, (short**)vals);
495 case types::InternalType::ScilabInt32:
496 return scilab_getInteger32Array(env, var, (int**)vals);
497 case types::InternalType::ScilabInt64:
498 return scilab_getInteger64Array(env, var, (long long**)vals);
499 case types::InternalType::ScilabUInt8:
500 return scilab_getUnsignedInteger8Array(env, var, (unsigned char**)vals);
501 case types::InternalType::ScilabUInt16:
502 return scilab_getUnsignedInteger16Array(env, var, (unsigned short**)vals);
503 case types::InternalType::ScilabUInt32:
504 return scilab_getUnsignedInteger32Array(env, var, (unsigned int**)vals);
505 case types::InternalType::ScilabUInt64:
506 return scilab_getUnsignedInteger64Array(env, var, (unsigned long long**)vals);
507 default:
508 return STATUS_ERROR;
509 }
510 }
511
API_PROTO(getInteger8Array)512 scilabStatus API_PROTO(getInteger8Array)(scilabEnv env, scilabVar var, char** vals)
513 {
514 types::Int8* i = (types::Int8*)var;
515 #ifdef __API_SCILAB_SAFE__
516 if (i->isInt8() == false)
517 {
518 scilab_setInternalError(env, L"getInteger8Array", _W("var must be a int8 variable"));
519 return STATUS_ERROR;
520 }
521 #endif
522 *vals = i->get();
523 return STATUS_OK;
524 }
525
API_PROTO(getInteger16Array)526 scilabStatus API_PROTO(getInteger16Array)(scilabEnv env, scilabVar var, short** vals)
527 {
528 types::Int16* i = (types::Int16*)var;
529 #ifdef __API_SCILAB_SAFE__
530 if (i->isInt16() == false)
531 {
532 scilab_setInternalError(env, L"getInteger16Array", _W("var must be a int16 variable"));
533 return STATUS_ERROR;
534 }
535 #endif
536 *vals = i->get();
537 return STATUS_OK;
538 }
539
API_PROTO(getInteger32Array)540 scilabStatus API_PROTO(getInteger32Array)(scilabEnv env, scilabVar var, int** vals)
541 {
542 types::Int32* i = (types::Int32*)var;
543 #ifdef __API_SCILAB_SAFE__
544 if (i->isInt32() == false)
545 {
546 scilab_setInternalError(env, L"getInteger32Array", _W("var must be a int32 variable"));
547 return STATUS_ERROR;
548 }
549 #endif
550 *vals = i->get();
551 return STATUS_OK;
552 }
553
API_PROTO(getInteger64Array)554 scilabStatus API_PROTO(getInteger64Array)(scilabEnv env, scilabVar var, long long** vals)
555 {
556 types::Int64* i = (types::Int64*)var;
557 #ifdef __API_SCILAB_SAFE__
558 if (i->isInt64() == false)
559 {
560 scilab_setInternalError(env, L"getInteger64Array", _W("var must be a int64 variable"));
561 return STATUS_ERROR;
562 }
563 #endif
564 *vals = i->get();
565 return STATUS_OK;
566 }
567
API_PROTO(getUnsignedInteger8Array)568 scilabStatus API_PROTO(getUnsignedInteger8Array)(scilabEnv env, scilabVar var, unsigned char** vals)
569 {
570 types::UInt8* i = (types::UInt8*)var;
571 #ifdef __API_SCILAB_SAFE__
572 if (i->isUInt8() == false)
573 {
574 scilab_setInternalError(env, L"getUnsignedInteger8Array", _W("var must be a uint8 variable"));
575 return STATUS_ERROR;
576 }
577 #endif
578 *vals = i->get();
579 return STATUS_OK;
580 }
581
API_PROTO(getUnsignedInteger16Array)582 scilabStatus API_PROTO(getUnsignedInteger16Array)(scilabEnv env, scilabVar var, unsigned short** vals)
583 {
584 types::UInt16* i = (types::UInt16*)var;
585 #ifdef __API_SCILAB_SAFE__
586 if (i->isUInt16() == false)
587 {
588 scilab_setInternalError(env, L"getUnsignedInteger16Array", _W("var must be a uint16 variable"));
589 return STATUS_ERROR;
590 }
591 #endif
592 *vals = i->get();
593 return STATUS_OK;
594 }
595
API_PROTO(getUnsignedInteger32Array)596 scilabStatus API_PROTO(getUnsignedInteger32Array)(scilabEnv env, scilabVar var, unsigned int** vals)
597 {
598 types::UInt32* i = (types::UInt32*)var;
599 #ifdef __API_SCILAB_SAFE__
600 if (i->isUInt32() == false)
601 {
602 scilab_setInternalError(env, L"getUnsignedInteger32Array", _W("var must be a uint32 variable"));
603 return STATUS_ERROR;
604 }
605 #endif
606 *vals = i->get();
607 return STATUS_OK;
608 }
609
API_PROTO(getUnsignedInteger64Array)610 scilabStatus API_PROTO(getUnsignedInteger64Array)(scilabEnv env, scilabVar var, unsigned long long** vals)
611 {
612 types::UInt64* i = (types::UInt64*)var;
613 #ifdef __API_SCILAB_SAFE__
614 if (i->isUInt64() == false)
615 {
616 scilab_setInternalError(env, L"getUnsignedInteger64Array", _W("var must be a uint64 variable"));
617 return STATUS_ERROR;
618 }
619 #endif
620 *vals = i->get();
621 return STATUS_OK;
622 }
623
API_PROTO(setIntegerArray)624 scilabStatus API_PROTO(setIntegerArray)(scilabEnv env, scilabVar var, const void* vals)
625 {
626 switch (((types::InternalType*)var)->getType())
627 {
628 case types::InternalType::ScilabInt8:
629 return scilab_setInteger8Array(env, var, (const char*)vals);
630 case types::InternalType::ScilabInt16:
631 return scilab_setInteger16Array(env, var, (const short*)vals);
632 case types::InternalType::ScilabInt32:
633 return scilab_setInteger32Array(env, var, (const int*)vals);
634 case types::InternalType::ScilabInt64:
635 return scilab_setInteger64Array(env, var, (const long long*)vals);
636 case types::InternalType::ScilabUInt8:
637 return scilab_setUnsignedInteger8Array(env, var, (const unsigned char*)vals);
638 case types::InternalType::ScilabUInt16:
639 return scilab_setUnsignedInteger16Array(env, var, (const unsigned short*)vals);
640 case types::InternalType::ScilabUInt32:
641 return scilab_setUnsignedInteger32Array(env, var, (const unsigned int*)vals);
642 case types::InternalType::ScilabUInt64:
643 return scilab_setUnsignedInteger64Array(env, var, (const unsigned long long*)vals);
644 default:
645 return STATUS_ERROR;
646
647 }
648 }
649
API_PROTO(setInteger8Array)650 scilabStatus API_PROTO(setInteger8Array)(scilabEnv env, scilabVar var, const char* vals)
651 {
652 types::Int8* i = (types::Int8*)var;
653 #ifdef __API_SCILAB_SAFE__
654 if (i->isInt8() == false)
655 {
656 scilab_setInternalError(env, L"setInteger8Array", _W("var must be a int8 variable"));
657 return STATUS_ERROR;
658 }
659 #endif
660 i->set(vals);
661 return STATUS_OK;
662 }
663
API_PROTO(setInteger16Array)664 scilabStatus API_PROTO(setInteger16Array)(scilabEnv env, scilabVar var, const short* vals)
665 {
666 types::Int16* i = (types::Int16*)var;
667 #ifdef __API_SCILAB_SAFE__
668 if (i->isInt16() == false)
669 {
670 scilab_setInternalError(env, L"setInteger16Array", _W("var must be a int16 variable"));
671 return STATUS_ERROR;
672 }
673 #endif
674 i->set(vals);
675 return STATUS_OK;
676 }
677
API_PROTO(setInteger32Array)678 scilabStatus API_PROTO(setInteger32Array)(scilabEnv env, scilabVar var, const int* vals)
679 {
680 types::Int32* i = (types::Int32*)var;
681 #ifdef __API_SCILAB_SAFE__
682 if (i->isInt32() == false)
683 {
684 scilab_setInternalError(env, L"setInteger32Array", _W("var must be a int32 variable"));
685 return STATUS_ERROR;
686 }
687 #endif
688 i->set(vals);
689 return STATUS_OK;
690 }
691
API_PROTO(setInteger64Array)692 scilabStatus API_PROTO(setInteger64Array)(scilabEnv env, scilabVar var, const long long* vals)
693 {
694 types::Int64* i = (types::Int64*)var;
695 #ifdef __API_SCILAB_SAFE__
696 if (i->isInt32() == false)
697 {
698 scilab_setInternalError(env, L"setInteger64Array", _W("var must be a int32 variable"));
699 return STATUS_ERROR;
700 }
701 #endif
702 i->set(vals);
703 return STATUS_OK;
704 }
705
API_PROTO(setUnsignedInteger8Array)706 scilabStatus API_PROTO(setUnsignedInteger8Array)(scilabEnv env, scilabVar var, const unsigned char* vals)
707 {
708 types::UInt8* i = (types::UInt8*)var;
709 #ifdef __API_SCILAB_SAFE__
710 if (i->isUInt8() == false)
711 {
712 scilab_setInternalError(env, L"setUnsignedInteger8Array", _W("var must be a uint8 variable"));
713 return STATUS_ERROR;
714 }
715 #endif
716 i->set(vals);
717 return STATUS_OK;
718 }
719
API_PROTO(setUnsignedInteger16Array)720 scilabStatus API_PROTO(setUnsignedInteger16Array)(scilabEnv env, scilabVar var, const unsigned short* vals)
721 {
722 types::UInt16* i = (types::UInt16*)var;
723 #ifdef __API_SCILAB_SAFE__
724 if (i->isUInt16() == false)
725 {
726 scilab_setInternalError(env, L"setUnsignedInteger16Array", _W("var must be a uint16 variable"));
727 return STATUS_ERROR;
728 }
729 #endif
730 i->set(vals);
731 return STATUS_OK;
732 }
733
API_PROTO(setUnsignedInteger32Array)734 scilabStatus API_PROTO(setUnsignedInteger32Array)(scilabEnv env, scilabVar var, const unsigned int* vals)
735 {
736 types::UInt32* i = (types::UInt32*)var;
737 #ifdef __API_SCILAB_SAFE__
738 if (i->isUInt32() == false)
739 {
740 scilab_setInternalError(env, L"setUnsignedInteger32Array", _W("var must be a uint32 variable"));
741 return STATUS_ERROR;
742 }
743 #endif
744 i->set(vals);
745 return STATUS_OK;
746 }
747
API_PROTO(setUnsignedInteger64Array)748 scilabStatus API_PROTO(setUnsignedInteger64Array)(scilabEnv env, scilabVar var, const unsigned long long* vals)
749 {
750 types::UInt64* i = (types::UInt64*)var;
751 #ifdef __API_SCILAB_SAFE__
752 if (i->isUInt64() == false)
753 {
754 scilab_setInternalError(env, L"setUnsignedInteger64Array", _W("var must be a uint64 variable"));
755 return STATUS_ERROR;
756 }
757 #endif
758 i->set(vals);
759 return STATUS_OK;
760 }
761