Coverity: api_scilab module memory errors fixed
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_stack_hypermat.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
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 * Please note that piece of code will be rewrited for the Scilab 6 family
15 * However, the API (profile of the functions in the header files) will be
16 * still available and supported in Scilab 6.
17 */
18
19 #include <stdio.h>
20 #include "double.hxx"
21 #include "bool.hxx"
22 #include "string.hxx"
23 #include "int.hxx"
24 #include "polynom.hxx"
25 #include "gatewaystruct.hxx"
26
27 extern "C"
28 {
29 #include "api_scilab.h"
30 #include "api_internal_common.h"
31 #include "api_internal_double.h"
32 #include "localization.h"
33
34 #include "call_scilab.h"
35 }
36
37 int isHypermatType(void* _pvCtx, int* _piAddress)
38 {
39     types::InternalType* it = (types::InternalType*)_piAddress;
40     if (it->isGenericType() == false)
41     {
42         return 0;
43     }
44
45     types::GenericType* gt = it->getAs<types::GenericType>();
46     if (gt->getDims() < 3)
47     {
48         return 0;
49     }
50
51     return 1;
52 }
53
54 int isHypermatComplex(void* _pvCtx, int* _piAddress)
55 {
56     types::InternalType* it = (types::InternalType*)_piAddress;
57     if (it->isGenericType() == false)
58     {
59         return 0;
60     }
61
62     types::GenericType* gt = it->getAs<types::GenericType>();
63     if (gt->isComplex())
64     {
65         return 1;
66     }
67
68     return 0;
69 }
70
71 SciErr getHypermatType(void *_pvCtx, int *_piAddress, int *_piType)
72 {
73     return getVarType(_pvCtx, _piAddress, _piType);
74 }
75
76 SciErr getHypermatOfIntegerPrecision(void *_pvCtx, int *_piAddress, int *_piPrecision)
77 {
78     return getMatrixOfIntegerPrecision(_pvCtx, _piAddress, _piPrecision);
79 }
80
81 SciErr getHypermatDimensions(void *_pvCtx, int *_piAddress, int **_dims, int *_ndims)
82 {
83     SciErr sciErr = sciErrInit();
84     types::InternalType* it = (types::InternalType*)_piAddress;
85     if (it->isGenericType() == false)
86     {
87         addErrorMessage(&sciErr, API_ERROR_NOT_MATRIX_TYPE, _("%s: matrix argument expected"), "getHypermatDimensions");
88         return sciErr;
89     }
90
91     types::GenericType* gt = it->getAs<types::GenericType>();
92     *_ndims = gt->getDims();
93     *_dims = gt->getDimsArray();
94     return sciErr;
95 }
96
97 static int getHypermatEntries(void* _pvCtx, int* _piAddress, void** _piEntriesAddress)
98 {
99     types::InternalType* it = (types::InternalType*)_piAddress;
100     if (it->isGenericType() == false)
101     {
102         return 1;
103     }
104
105     switch (it->getType())
106     {
107         case types::InternalType::ScilabDouble:
108         {
109             *_piEntriesAddress = it->getAs<types::Double>();
110             break;
111         }
112         case types::InternalType::ScilabBool:
113         {
114             *_piEntriesAddress = it->getAs<types::Bool>();
115             break;
116         }
117         case types::InternalType::ScilabString:
118         {
119             *_piEntriesAddress = it->getAs<types::String>();
120             break;
121         }
122         case types::InternalType::ScilabPolynom:
123         {
124             *_piEntriesAddress = it->getAs<types::Polynom>();
125             break;
126         }
127         case types::InternalType::ScilabInt8:
128         {
129             *_piEntriesAddress = it->getAs<types::Int8>();
130             break;
131         }
132         case types::InternalType::ScilabInt16:
133         {
134             *_piEntriesAddress = it->getAs<types::Int16>();
135             break;
136         }
137         case types::InternalType::ScilabInt32:
138         {
139             *_piEntriesAddress = it->getAs<types::Int32>();
140             break;
141         }
142         case types::InternalType::ScilabInt64:
143         {
144             *_piEntriesAddress = it->getAs<types::Int64>();
145             break;
146         }
147         case types::InternalType::ScilabUInt8:
148         {
149             *_piEntriesAddress = it->getAs<types::UInt8>();
150             break;
151         }
152         case types::InternalType::ScilabUInt16:
153         {
154             *_piEntriesAddress = it->getAs<types::UInt16>();
155             break;
156         }
157         case types::InternalType::ScilabUInt32:
158         {
159             *_piEntriesAddress = it->getAs<types::UInt32>();
160             break;
161         }
162         case types::InternalType::ScilabUInt64:
163         {
164             *_piEntriesAddress = it->getAs<types::UInt64>();
165             break;
166         }
167         default:
168         {
169             *_piEntriesAddress = NULL;
170             break;
171         }
172     }
173
174     return 0;
175 }
176
177 SciErr getHypermatOfDouble(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, double** _pdblReal)
178 {
179     SciErr sciErr = sciErrInit();
180     void* entries = NULL;
181
182     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
183     if (ret || entries == NULL || ((types::InternalType*)entries)->isDouble() == false)
184     {
185         addErrorMessage(&sciErr, API_ERROR_GET_DOUBLE, _("%s: Unable to get argument #%d"), "getHypermatOfDouble", getRhsFromAddress(_pvCtx, _piAddress));
186         return sciErr;
187     }
188
189     types::Double* d = (types::Double*)entries;
190     *_dims = d->getDimsArray();
191     *_ndims = d->getDims();
192     *_pdblReal = d->get();
193     return sciErr;
194 }
195
196 SciErr getComplexHypermatOfDouble(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, double** _pdblReal, double** _pdblImg)
197 {
198     SciErr sciErr = sciErrInit();
199     void* entries = NULL;
200
201     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
202     if (ret || entries == NULL || ((types::InternalType*)entries)->isDouble() == false)
203     {
204         addErrorMessage(&sciErr, API_ERROR_GET_DOUBLE, _("%s: Unable to get argument #%d"), "getHypermatOfDouble", getRhsFromAddress(_pvCtx, _piAddress));
205         return sciErr;
206     }
207
208     types::Double* d = (types::Double*)entries;
209     *_dims = d->getDimsArray();
210     *_ndims = d->getDims();
211     *_pdblReal = d->get();
212     *_pdblImg = d->getImg();
213     return sciErr;
214 }
215
216 SciErr getHypermatPolyVariableName(void* _pvCtx, int* _piAddress, char* _pstVarName, int* _piVarNameLen)
217 {
218     SciErr sciErr = sciErrInit();
219     void * entries = NULL;
220
221     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
222
223     if (ret || entries == NULL || ((types::InternalType*)entries)->isPoly() == false)
224     {
225         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatPolyVariableName");
226         return sciErr;
227     }
228
229     types::Polynom* p = (types::Polynom*)entries;
230     std::wstring var = p->getVariableName();
231
232     char* varname = wide_string_to_UTF8(var.data());
233     *_piVarNameLen = static_cast<int>(strlen(varname));
234
235     if (_pstVarName)
236     {
237         strcpy(_pstVarName, varname);
238     }
239
240     FREE(varname);
241     return sciErr;
242 }
243
244 SciErr getHypermatOfPoly(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int* _piNbCoef, double** _pdblReal)
245 {
246     SciErr sciErr = sciErrInit();
247     void * entries = NULL;
248
249     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
250
251     if (ret || entries == NULL || ((types::InternalType*)entries)->isPoly() == false)
252     {
253         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfPoly");
254         return sciErr;
255     }
256
257     types::Polynom* p = (types::Polynom*)entries;
258     *_dims = p->getDimsArray();
259     *_ndims = p->getDims();
260
261     if (_piNbCoef == NULL)
262     {
263         return sciErr;
264     }
265
266     p->getSizes(_piNbCoef);
267
268     if (_pdblReal == NULL)
269     {
270         return sciErr;
271     }
272
273     int size = p->getSize();
274     types::SinglePoly** s = p->get();
275
276     for (int i = 0; i < size; i++)
277     {
278         memcpy(_pdblReal[i], s[i]->get(), sizeof(double) * s[i]->getSize());
279     }
280
281     return sciErr;
282 }
283
284 SciErr getComplexHypermatOfPoly(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
285 {
286     SciErr sciErr = sciErrInit();
287     void * entries = NULL;
288
289     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
290
291     if (ret || entries == NULL || ((types::InternalType*)entries)->isPoly() == false)
292     {
293         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getComplexHypermatOfPoly");
294         return sciErr;
295     }
296
297     types::Polynom* p = (types::Polynom*)entries;
298
299     if (p->isComplex() == false)
300     {
301         addErrorMessage(&sciErr, API_ERROR_INVALID_COMPLEXITY, _("%s: Bad call to get a non complex matrix"), "getComplexHypermatOfPoly");
302         return sciErr;
303     }
304
305     *_dims = p->getDimsArray();
306     *_ndims = p->getDims();
307
308     if (_piNbCoef == NULL)
309     {
310         return sciErr;
311     }
312
313     p->getSizes(_piNbCoef);
314
315     if (_pdblReal == NULL)
316     {
317         return sciErr;
318     }
319
320     int size = p->getSize();
321     types::SinglePoly** s = p->get();
322
323     for (int i = 0; i < size; i++)
324     {
325         memcpy(_pdblReal[i], s[i]->get(), sizeof(double) * s[i]->getSize());
326         memcpy(_pdblImg[i], s[i]->getImg(), sizeof(double) * s[i]->getSize());
327     }
328
329     return sciErr;
330 }
331
332 SciErr getHypermatOfString(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int* _piLength, char** _pstStrings)
333 {
334     SciErr sciErr = sciErrInit();
335     void * entries = NULL;
336
337     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
338
339     if (ret || entries == NULL || ((types::InternalType*)entries)->isString() == false)
340     {
341         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfString");
342         return sciErr;
343     }
344
345     types::String* p = (types::String*)entries;
346     *_dims = p->getDimsArray();
347     *_ndims = p->getDims();
348     int size = p->getSize();
349
350     if (_piLength == NULL)
351     {
352         return sciErr;
353     }
354
355
356     if (_pstStrings == NULL || *_pstStrings == NULL)
357     {
358         wchar_t** s = p->get();
359         for (int i = 0; i < size; i++)
360         {
361             char* c = wide_string_to_UTF8(s[i]);
362             _piLength[i] = (int)strlen(c);
363             FREE(c);
364         }
365     }
366     else
367     {
368         wchar_t** s = p->get();
369         for (int i = 0; i < size; i++)
370         {
371             if (_pstStrings[i] == NULL)
372             {
373                 addErrorMessage(&sciErr, API_ERROR_INVALID_SUBSTRING_POINTER, _("%s: Invalid argument address"), "getHypermatOfString");
374                 return sciErr;
375             }
376
377             char* c = wide_string_to_UTF8(s[i]);
378             strcpy(_pstStrings[i], c);
379             FREE(c);
380         }
381     }
382
383     return sciErr;
384 }
385
386 SciErr getHypermatOfWideString(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int* _piLength, wchar_t** _pwstStrings)
387 {
388     SciErr sciErr = sciErrInit();
389     void * entries = NULL;
390
391     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
392
393     if (ret || entries == NULL || ((types::InternalType*)entries)->isString() == false)
394     {
395         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfWideString");
396         return sciErr;
397     }
398
399     types::String* p = (types::String*)entries;
400     *_dims = p->getDimsArray();
401     *_ndims = p->getDims();
402     int size = p->getSize();
403
404     if (_piLength == NULL)
405     {
406         return sciErr;
407     }
408
409
410     if (_pwstStrings == NULL || *_pwstStrings == NULL)
411     {
412         wchar_t** s = p->get();
413         for (int i = 0; i < size; i++)
414         {
415             _piLength[i] = (int)wcslen(s[i]);
416         }
417     }
418     else
419     {
420         wchar_t** s = p->get();
421         for (int i = 0; i < size; i++)
422         {
423             if (_pwstStrings[i] == NULL)
424             {
425                 addErrorMessage(&sciErr, API_ERROR_INVALID_SUBSTRING_POINTER, _("%s: Invalid argument address"), "getHypermatOfWideString");
426                 return sciErr;
427             }
428
429             wcscpy(_pwstStrings[i], s[i]);
430         }
431     }
432
433     return sciErr;
434 }
435
436 SciErr getHypermatOfInteger8(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, char** _pcData8)
437 {
438     SciErr sciErr = sciErrInit();
439     void * entries = NULL;
440
441     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
442
443     if (ret || entries == NULL || ((types::InternalType*)entries)->isInt8() == false)
444     {
445         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfInteger8");
446         return sciErr;
447     }
448
449     types::Int8* p = (types::Int8*)entries;
450     *_dims = p->getDimsArray();
451     *_ndims = p->getDims();
452     *_pcData8 = p->get();
453     return sciErr;
454 }
455
456 SciErr getHypermatOfUnsignedInteger8(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, unsigned char** _pucData8)
457 {
458     SciErr sciErr = sciErrInit();
459     void * entries = NULL;
460
461     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
462
463     if (ret || entries == NULL || ((types::InternalType*)entries)->isUInt8() == false)
464     {
465         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfUnsignedInteger8");
466         return sciErr;
467     }
468
469     types::UInt8* p = (types::UInt8*)entries;
470     *_dims = p->getDimsArray();
471     *_ndims = p->getDims();
472     *_pucData8 = p->get();
473     return sciErr;
474 }
475
476 SciErr getHypermatOfInteger16(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, short** _psData16)
477 {
478     SciErr sciErr = sciErrInit();
479     void * entries = NULL;
480
481     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
482
483     if (ret || entries == NULL || ((types::InternalType*)entries)->isInt16() == false)
484     {
485         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfInteger16");
486         return sciErr;
487     }
488
489     types::Int16* p = (types::Int16*)entries;
490     *_dims = p->getDimsArray();
491     *_ndims = p->getDims();
492     *_psData16 = p->get();
493     return sciErr;
494 }
495
496 SciErr getHypermatOfUnsignedInteger16(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, unsigned short** _pusData16)
497 {
498     SciErr sciErr = sciErrInit();
499     void * entries = NULL;
500
501     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
502
503     if (ret || entries == NULL || ((types::InternalType*)entries)->isUInt16() == false)
504     {
505         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfUnsignedInteger16");
506         return sciErr;
507     }
508
509     types::UInt16* p = (types::UInt16*)entries;
510     *_dims = p->getDimsArray();
511     *_ndims = p->getDims();
512     *_pusData16 = p->get();
513     return sciErr;
514 }
515
516 SciErr getHypermatOfInteger32(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int** _piData32)
517 {
518     SciErr sciErr = sciErrInit();
519     void * entries = NULL;
520
521     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
522
523     if (ret || entries == NULL || ((types::InternalType*)entries)->isInt32() == false)
524     {
525         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfInteger32");
526         return sciErr;
527     }
528
529     types::Int32* p = (types::Int32*)entries;
530     *_dims = p->getDimsArray();
531     *_ndims = p->getDims();
532     *_piData32 = p->get();
533     return sciErr;
534 }
535
536 SciErr getHypermatOfUnsignedInteger32(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, unsigned int** _puiData32)
537 {
538     SciErr sciErr = sciErrInit();
539     void * entries = NULL;
540
541     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
542
543     if (ret || entries == NULL || ((types::InternalType*)entries)->isUInt32() == false)
544     {
545         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfUnsignedInteger32");
546         return sciErr;
547     }
548
549     types::UInt32* p = (types::UInt32*)entries;
550     *_dims = p->getDimsArray();
551     *_ndims = p->getDims();
552     *_puiData32 = p->get();
553     return sciErr;
554 }
555
556 SciErr getHypermatOfInteger64(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, long long** _pllData64)
557 {
558     SciErr sciErr = sciErrInit();
559     void * entries = NULL;
560
561     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
562
563     if (ret || entries == NULL || ((types::InternalType*)entries)->isInt64() == false)
564     {
565         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfInteger64");
566         return sciErr;
567     }
568
569     types::Int64* p = (types::Int64*)entries;
570     *_dims = p->getDimsArray();
571     *_ndims = p->getDims();
572     *_pllData64 = p->get();
573     return sciErr;
574 }
575
576 SciErr getHypermatOfUnsignedInteger64(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, unsigned long long** _pullData64)
577 {
578     SciErr sciErr = sciErrInit();
579     void * entries = NULL;
580
581     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
582
583     if (ret || entries == NULL || ((types::InternalType*)entries)->isUInt64() == false)
584     {
585         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfUnsignedInteger64");
586         return sciErr;
587     }
588
589     types::UInt64* p = (types::UInt64*)entries;
590     *_dims = p->getDimsArray();
591     *_ndims = p->getDims();
592     *_pullData64 = p->get();
593     return sciErr;
594 }
595
596 SciErr getHypermatOfBoolean(void* _pvCtx, int* _piAddress, int **_dims, int *_ndims, int** _piBool)
597 {
598     SciErr sciErr = sciErrInit();
599     void * entries = NULL;
600
601     int ret = getHypermatEntries(_pvCtx, _piAddress, &entries);
602
603     if (ret || entries == NULL || ((types::InternalType*)entries)->isBool() == false)
604     {
605         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getHypermatOfBoolean");
606         return sciErr;
607     }
608
609     types::Bool* p = (types::Bool*)entries;
610     *_dims = p->getDimsArray();
611     *_ndims = p->getDims();
612     *_piBool = p->get();
613     return sciErr;
614 }
615
616 SciErr createHypermatOfString(void *_pvCtx, int _iVar, int * _dims, int _ndims, const char* const* _pstStrings)
617 {
618     SciErr sciErr = sciErrInit();
619     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
620     types::typed_list in = *pStr->m_pIn;
621     types::InternalType** out = pStr->m_pOut;
622     int rhs = _iVar - *getNbInputArgument(_pvCtx);
623
624     types::String* p = new types::String(_ndims, _dims);
625     int size = p->getSize();
626
627     if (size == 0)
628     {
629         delete p;
630         out[rhs - 1] = types::Double::Empty();
631         return sciErr;
632     }
633
634     for (int i = 0; i < size; ++i)
635     {
636         wchar_t* w = to_wide_string(_pstStrings[i]);
637         p->set(i, w);
638         FREE(w);
639     }
640
641     out[rhs - 1] = p;
642     return sciErr;
643 }
644
645 SciErr createHypermatOfPoly(void *_pvCtx, int _iVar, char* _pstVarName, int * _dims, int _ndims, const int* _piNbCoef, const double* const* _pdblReal)
646 {
647     SciErr sciErr = sciErrInit();
648     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
649     types::typed_list in = *pStr->m_pIn;
650     types::InternalType** out = pStr->m_pOut;
651     int rhs = _iVar - *getNbInputArgument(_pvCtx);
652
653     wchar_t* w = to_wide_string(_pstVarName);
654     types::Polynom* p = new types::Polynom(w, _ndims, _dims, _piNbCoef);
655
656     int size = p->getSize();
657     if (size == 0)
658     {
659         delete p;
660         out[rhs - 1] = types::Double::Empty();
661         FREE(w);
662         return sciErr;
663     }
664
665     types::SinglePoly** s = p->get();
666
667     for (int i = 0; i < size; ++i)
668     {
669         s[i]->setCoef(_pdblReal[i], NULL);
670     }
671
672     out[rhs - 1] = p;
673     FREE(w);
674     return sciErr;
675 }
676
677 SciErr createComplexHypermatOfPoly(void *_pvCtx, int _iVar, char* _pstVarName, int * _dims, int _ndims, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
678 {
679     SciErr sciErr = sciErrInit();
680     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
681     types::typed_list in = *pStr->m_pIn;
682     types::InternalType** out = pStr->m_pOut;
683     int rhs = _iVar - *getNbInputArgument(_pvCtx);
684
685     wchar_t* w = to_wide_string(_pstVarName);
686     types::Polynom* p = new types::Polynom(w, _ndims, _dims, _piNbCoef);
687     p->setComplex(true);
688
689     int size = p->getSize();
690     if (size == 0)
691     {
692         delete p;
693         out[rhs - 1] = types::Double::Empty();
694         FREE(w);
695         return sciErr;
696     }
697
698     types::SinglePoly** s = p->get();
699
700     for (int i = 0; i < size; ++i)
701     {
702         s[i]->setCoef(_pdblReal[i], _pdblImg[i]);
703     }
704
705     out[rhs - 1] = p;
706     FREE(w);
707     return sciErr;
708 }
709
710 SciErr allocHypermatOfDouble(void *_pvCtx, int _iVar, int * _dims, int _ndims, double** _pdblReal)
711 {
712     SciErr sciErr = sciErrInit();
713     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
714     types::typed_list in = *pStr->m_pIn;
715     types::InternalType** out = pStr->m_pOut;
716     int rhs = _iVar - *getNbInputArgument(_pvCtx);
717
718     types::Double* p = new types::Double(_ndims, _dims);
719
720     int size = p->getSize();
721     if (size == 0)
722     {
723         delete p;
724         out[rhs - 1] = types::Double::Empty();
725         return sciErr;
726     }
727
728     *_pdblReal = p->get();
729     out[rhs - 1] = p;
730     return sciErr;
731 }
732
733 SciErr createHypermatOfDouble(void *_pvCtx, int _iVar, int * _dims, int _ndims, const double * _pdblReal)
734 {
735     SciErr sciErr = sciErrInit();
736     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
737     types::typed_list in = *pStr->m_pIn;
738     types::InternalType** out = pStr->m_pOut;
739     int rhs = _iVar - *getNbInputArgument(_pvCtx);
740
741     types::Double* p = new types::Double(_ndims, _dims);
742
743     int size = p->getSize();
744     if (size == 0)
745     {
746         delete p;
747         out[rhs - 1] = types::Double::Empty();
748         return sciErr;
749     }
750
751     p->set(_pdblReal);
752     out[rhs - 1] = p;
753     return sciErr;
754 }
755
756 SciErr createComplexHypermatOfDouble(void *_pvCtx, int _iVar, int * _dims, int _ndims, const double * _pdblReal, const double * _pdblImg)
757 {
758     SciErr sciErr = sciErrInit();
759     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
760     types::typed_list in = *pStr->m_pIn;
761     types::InternalType** out = pStr->m_pOut;
762     int rhs = _iVar - *getNbInputArgument(_pvCtx);
763
764     types::Double* p = new types::Double(_ndims, _dims, true);
765
766     int size = p->getSize();
767     if (size == 0)
768     {
769         delete p;
770         out[rhs - 1] = types::Double::Empty();
771         return sciErr;
772     }
773
774     p->set(_pdblReal);
775     p->setImg(_pdblImg);
776     out[rhs - 1] = p;
777     return sciErr;
778 }
779
780 SciErr createHypermatOfBoolean(void *_pvCtx, int _iVar, int * _dims, int _ndims, const int * _piBool)
781 {
782     SciErr sciErr = sciErrInit();
783     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
784     types::typed_list in = *pStr->m_pIn;
785     types::InternalType** out = pStr->m_pOut;
786     int rhs = _iVar - *getNbInputArgument(_pvCtx);
787
788     types::Bool* p = new types::Bool(_ndims, _dims);
789
790     int size = p->getSize();
791     if (size == 0)
792     {
793         delete p;
794         out[rhs - 1] = types::Double::Empty();
795         return sciErr;
796     }
797
798     p->set(_piBool);
799     out[rhs - 1] = p;
800     return sciErr;
801 }
802
803 SciErr createHypermatOfInteger8(void *_pvCtx, int _iVar, int * _dims, int _ndims, const char * _pcData8)
804 {
805     SciErr sciErr = sciErrInit();
806     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
807     types::typed_list in = *pStr->m_pIn;
808     types::InternalType** out = pStr->m_pOut;
809     int rhs = _iVar - *getNbInputArgument(_pvCtx);
810
811     types::Int8* p = new types::Int8(_ndims, _dims);
812
813     int size = p->getSize();
814     if (size == 0)
815     {
816         delete p;
817         out[rhs - 1] = types::Double::Empty();
818         return sciErr;
819     }
820
821     p->set(_pcData8);
822     out[rhs - 1] = p;
823     return sciErr;
824 }
825
826 SciErr createHypermatOfUnsignedInteger8(void *_pvCtx, int _iVar, int * _dims, int _ndims, const unsigned char * _pucData8)
827 {
828     SciErr sciErr = sciErrInit();
829     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
830     types::typed_list in = *pStr->m_pIn;
831     types::InternalType** out = pStr->m_pOut;
832     int rhs = _iVar - *getNbInputArgument(_pvCtx);
833
834     types::UInt8* p = new types::UInt8(_ndims, _dims);
835
836     int size = p->getSize();
837     if (size == 0)
838     {
839         delete p;
840         out[rhs - 1] = types::Double::Empty();
841         return sciErr;
842     }
843
844     p->set(_pucData8);
845     out[rhs - 1] = p;
846     return sciErr;
847 }
848
849 SciErr createHypermatOfInteger16(void *_pvCtx, int _iVar, int * _dims, int _ndims, const short * _psData16)
850 {
851     SciErr sciErr = sciErrInit();
852     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
853     types::typed_list in = *pStr->m_pIn;
854     types::InternalType** out = pStr->m_pOut;
855     int rhs = _iVar - *getNbInputArgument(_pvCtx);
856
857     types::Int16* p = new types::Int16(_ndims, _dims);
858
859     int size = p->getSize();
860     if (size == 0)
861     {
862         delete p;
863         out[rhs - 1] = types::Double::Empty();
864         return sciErr;
865     }
866
867     p->set(_psData16);
868     out[rhs - 1] = p;
869     return sciErr;
870 }
871
872 SciErr createHypermatOfUnsignedInteger16(void *_pvCtx, int _iVar, int * _dims, int _ndims, const unsigned short * _pusData16)
873 {
874     SciErr sciErr = sciErrInit();
875     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
876     types::typed_list in = *pStr->m_pIn;
877     types::InternalType** out = pStr->m_pOut;
878     int rhs = _iVar - *getNbInputArgument(_pvCtx);
879
880     types::UInt16* p = new types::UInt16(_ndims, _dims);
881
882     int size = p->getSize();
883     if (size == 0)
884     {
885         delete p;
886         out[rhs - 1] = types::Double::Empty();
887         return sciErr;
888     }
889
890     p->set(_pusData16);
891     out[rhs - 1] = p;
892     return sciErr;
893 }
894
895 SciErr createHypermatOfInteger32(void *_pvCtx, int _iVar, int * _dims, int _ndims, const int * _piData32)
896 {
897     SciErr sciErr = sciErrInit();
898     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
899     types::typed_list in = *pStr->m_pIn;
900     types::InternalType** out = pStr->m_pOut;
901     int rhs = _iVar - *getNbInputArgument(_pvCtx);
902
903     types::Int32* p = new types::Int32(_ndims, _dims);
904
905     int size = p->getSize();
906     if (size == 0)
907     {
908         delete p;
909         out[rhs - 1] = types::Double::Empty();
910         return sciErr;
911     }
912
913     p->set(_piData32);
914     out[rhs - 1] = p;
915     return sciErr;
916 }
917
918 SciErr createHypermatOfUnsignedInteger32(void *_pvCtx, int _iVar, int * _dims, int _ndims, const unsigned int * _puiData32)
919 {
920     SciErr sciErr = sciErrInit();
921     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
922     types::typed_list in = *pStr->m_pIn;
923     types::InternalType** out = pStr->m_pOut;
924     int rhs = _iVar - *getNbInputArgument(_pvCtx);
925
926     types::UInt32* p = new types::UInt32(_ndims, _dims);
927
928     int size = p->getSize();
929     if (size == 0)
930     {
931         delete p;
932         out[rhs - 1] = types::Double::Empty();
933         return sciErr;
934     }
935
936     p->set(_puiData32);
937     out[rhs - 1] = p;
938     return sciErr;
939 }
940
941 SciErr createHypermatOfInteger64(void *_pvCtx, int _iVar, int * _dims, int _ndims, const long long* _pllData64)
942 {
943     SciErr sciErr = sciErrInit();
944     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
945     types::typed_list in = *pStr->m_pIn;
946     types::InternalType** out = pStr->m_pOut;
947     int rhs = _iVar - *getNbInputArgument(_pvCtx);
948
949     types::Int64* p = new types::Int64(_ndims, _dims);
950
951     int size = p->getSize();
952     if (size == 0)
953     {
954         delete p;
955         out[rhs - 1] = types::Double::Empty();
956         return sciErr;
957     }
958
959     p->set(_pllData64);
960     out[rhs - 1] = p;
961     return sciErr;
962 }
963
964 SciErr createHypermatOfUnsignedInteger64(void *_pvCtx, int _iVar, int * _dims, int _ndims, const unsigned long long* _pullData64)
965 {
966     SciErr sciErr = sciErrInit();
967     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
968     types::typed_list in = *pStr->m_pIn;
969     types::InternalType** out = pStr->m_pOut;
970     int rhs = _iVar - *getNbInputArgument(_pvCtx);
971
972     types::UInt64* p = new types::UInt64(_ndims, _dims);
973
974     int size = p->getSize();
975     if (size == 0)
976     {
977         delete p;
978         out[rhs - 1] = types::Double::Empty();
979         return sciErr;
980     }
981
982     p->set(_pullData64);
983     out[rhs - 1] = p;
984     return sciErr;
985 }