Coverity #1321214, #1321215, #1321217, #1321220, #1321223, #1321224, #1321221, #13212...
[scilab.git] / scilab / modules / ui_data / sci_gateway / cpp / sci_editvar.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - DIGITEO - Allan CORNET
4  * Copyright (C) 2010 - DIGITEO - Allan SIMON
5  * Copyright (C) 2010 - DIGITEO - Bruno JOFRET
6  * Copyright (C) 2011 - DIGITEO - Calixte DENIZET
7  *
8  * Copyright (C) 2012 - 2016 - Scilab Enterprises
9  *
10  * This file is hereby licensed under the terms of the GNU GPL v2.0,
11  * pursuant to article 5.3.4 of the CeCILL v.2.1.
12  * This file was originally licensed under the terms of the CeCILL v2.1,
13  * and continues to be available under such terms.
14  * For more information, see the COPYING file which you should have received
15  * along with this program.
16  *
17  */
18
19 #include <iostream>
20 #include "EditVar.hxx"
21 #include "GiwsException.hxx"
22 //#include "ScilabToJava.hxx"
23
24 extern "C"
25 {
26 #include "api_scilab.h"
27 #include "localization.h"
28 #include "Scierror.h"
29 #include "sci_malloc.h"
30 #include "freeArrayOfString.h"
31 #include "sciprint.h"
32 #include "getScilabJavaVM.h"
33 #include "localization.h"
34 #include <time.h>
35 }
36
37 using namespace org_scilab_modules_ui_data;
38 /*--------------------------------------------------------------------------*/
39 template <typename T, typename U>
40 T** wrap(U * x, int r, int c)
41 {
42     T ** xx = new T*[r];
43     for (int i = 0; i < r; i++)
44     {
45         xx[i] = new T[c];
46         for (int j = 0; j < c; j++)
47         {
48             xx[i][j] = static_cast<T>(x[j * r + i]);
49         }
50     }
51
52     return xx;
53 }
54 /*--------------------------------------------------------------------------*/
55 /* For example if the matrix is [1 2 0 0 0;0 1 2 0 0;0 2 1 3 0 0;0 0 0 0 0;0 0 0 0 1], then
56    r=5, c=5, nbItem=8, nbItemRow=[2 2 3 0 1], colPos=[1 2 2 3 2 3 4 5] and x=[1 2 1 2 2 1 3 1] */
57 double ** wrapSparse(int nbItem, int * nbItemRow, int * colPos, int r, int c, double * x)
58 {
59     double ** xx = new double*[r];
60     int prev = 0;
61     for (int i = 0; i < r; i++)
62     {
63         xx[i] = new double[c];
64         memset(xx[i], 0, c * sizeof(double));
65         for (int j = 0; j < nbItemRow[i]; j++)
66         {
67             xx[i][colPos[prev + j] - 1] = x[prev + j];
68         }
69         prev += nbItemRow[i];
70     }
71
72     return xx;
73 }
74 /*--------------------------------------------------------------------------*/
75 /* boolean version */
76 int ** wrapSparse(int nbItem, int * nbItemRow, int * colPos, int r, int c)
77 {
78     int ** xx = new int*[r];
79     int prev = 0;
80     for (int i = 0; i < r; i++)
81     {
82         xx[i] = new int[c];
83         memset(xx[i], 0, c * sizeof(int));
84         for (int j = 0; j < nbItemRow[i]; j++)
85         {
86             xx[i][colPos[prev + j] - 1] = 1;
87         }
88         prev += nbItemRow[i];
89     }
90
91     return xx;
92 }
93 /*--------------------------------------------------------------------------*/
94 template <typename T>
95 void clearWrap(T ** x, int r)
96 {
97     for (int i = 0; i < r; i++)
98     {
99         delete [] x[i];
100     }
101
102     delete[] x;
103 }
104 /*--------------------------------------------------------------------------*/
105 int sci_editvar(char * fname, void* pvApiCtx)
106 {
107     CheckRhs(1, 4); /* TODO change this in the future */
108     CheckLhs(0, 1);
109
110     SciErr sciErr;
111
112     int m1 = 0, n1 = 0;
113
114     int * piAddr = NULL;
115     int iType = 0;
116     int iCols = 0;
117     int iRows = 0;
118
119     int * piBool = NULL;
120     int ** ppiBool = NULL;
121
122     char * piInt8 = NULL;
123     char ** ppiInt8 = NULL;
124
125     unsigned char * piUInt8 = NULL;
126     short ** ppiUInt8 = NULL;
127
128     short * piInt16 = NULL;
129     short ** ppiInt16 = NULL;
130
131     unsigned short * piUInt16 = NULL;
132     int ** ppiUInt16 = NULL;
133
134     int * piInt32 = NULL;
135     int ** ppiInt32 = NULL;
136
137     unsigned int * piUInt32 = NULL;
138     long long int ** ppiUInt32 = NULL;
139
140     int iComplex = 0;
141     double * pdblReal = NULL;
142     double * pdblImg = NULL;
143     double ** ppdblRealMatrix = NULL;
144     double ** ppdblImgMatrix = NULL;
145
146     char ** pstData = NULL;
147     char *** ppstData = NULL;
148
149     int * piAddressVarOne = NULL;
150     char * pStVarOne = NULL;
151     int lenStVarOne = 0;
152
153     int * addr = NULL;
154     double * rowsIndex = NULL;
155     int nbRowsIndex = 0;
156     double * colsIndex = NULL;
157     int nbColsIndex = 0;
158
159     int piNbItem = 0;
160     int * piNbItemRow = NULL;
161     int * piColPos = NULL;
162
163     if (Rhs == 3)
164     {
165         Scierror(999, _("%s: Wrong number of input argument(s): %d, %d or %d expected.\n"), fname, 1, 2, 4);
166         return 0;
167     }
168
169     /* get address */
170     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
171     if (sciErr.iErr)
172     {
173         printError(&sciErr, 0);
174         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
175         return 0;
176     }
177
178     sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType);
179     if (sciErr.iErr)
180     {
181         printError(&sciErr, 0);
182         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
183         return 0;
184     }
185
186     if (iType != sci_strings)
187     {
188         Scierror(999, _("%s: Wrong type for input argument #%d: A String expected.\n"), fname, 1);
189         return 0;
190     }
191
192     /* get variable name */
193     if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &pStVarOne))
194     {
195         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
196         return 0;
197     }
198
199     if (strcmp(pStVarOne, "ans") == 0)
200     {
201         Scierror(999, _("%s: ans cannot be edited.\n"), fname);
202         FREE(pStVarOne);
203         return 0;
204     }
205
206     /* get address of the variable*/
207     sciErr = getVarAddressFromName(pvApiCtx, pStVarOne, &piAddr);
208     if (sciErr.iErr)
209     {
210         Scierror(4, _("%s: Undefined variable: %s.\n"), fname, pStVarOne);
211         FREE(pStVarOne);
212         return 0;
213     }
214
215     /* Workaround to check for permanent variable.*/
216
217     if (strcmp(pStVarOne, "$")                      == 0 ||
218             strcmp(pStVarOne, "%e")                 == 0 ||
219             strcmp(pStVarOne, "%eps")           == 0 ||
220             strcmp(pStVarOne, "%fftw")          == 0 ||
221             strcmp(pStVarOne, "%f")                 == 0 ||
222             strcmp(pStVarOne, "%F")                 == 0 ||
223             strcmp(pStVarOne, "%gui")           == 0 ||
224             strcmp(pStVarOne, "%i")                 == 0 ||
225             strcmp(pStVarOne, "%io")            == 0 ||
226             strcmp(pStVarOne, "%inf")           == 0 ||
227             strcmp(pStVarOne, "%nan")           == 0 ||
228             strcmp(pStVarOne, "%pi")            == 0 ||
229             strcmp(pStVarOne, "%s")             == 0 ||
230             strcmp(pStVarOne, "%tk")            == 0 ||
231             strcmp(pStVarOne, "%t")             == 0 ||
232             strcmp(pStVarOne, "%T")             == 0 ||
233             strcmp(pStVarOne, "%z")             == 0 ||
234             strcmp(pStVarOne, "evoid")      == 0 ||
235             strcmp(pStVarOne, "home")           == 0 ||
236             strcmp(pStVarOne, "PWD")            == 0 ||
237             strcmp(pStVarOne, "SCI")            == 0 ||
238             strcmp(pStVarOne, "SCIHOME")        == 0 ||
239             strcmp(pStVarOne, "TMPDIR")         == 0 )
240     {
241         Scierror(13, _("Redefining permanent variable.\n"), fname);
242         FREE(pStVarOne);
243         return 0;
244     }
245
246     if (Rhs == 1)
247     {
248         /* get address of the variable*/
249         sciErr = getVarAddressFromName(pvApiCtx, pStVarOne, &piAddr);
250         if (sciErr.iErr)
251         {
252             Scierror(4, _("%s: Undefined variable: %s.\n"), fname, pStVarOne);
253             FREE(pStVarOne);
254             return 0;
255         }
256     }
257     else
258     {
259         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
260         if (sciErr.iErr)
261         {
262             FREE(pStVarOne);
263             printError(&sciErr, 0);
264             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
265             return 0;
266         }
267     }
268
269     if (Rhs == 4)
270     {
271         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &addr);
272         if (sciErr.iErr)
273         {
274             printError(&sciErr, 0);
275             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
276             FREE(pStVarOne);
277             return 0;
278         }
279
280         if (!isDoubleType(pvApiCtx, addr))
281         {
282             Scierror(999, _("%s: Wrong type for input argument #%d: Double expected.\n"), fname, 3);
283             FREE(pStVarOne);
284             return 0;
285         }
286
287         sciErr = getMatrixOfDouble(pvApiCtx, addr, &iRows, &iCols, &rowsIndex);
288         if (sciErr.iErr)
289         {
290             FREE(pStVarOne);
291             printError(&sciErr, 0);
292             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
293             return 0;
294         }
295
296         nbRowsIndex = iRows * iCols;
297
298         sciErr = getVarAddressFromPosition(pvApiCtx, 4, &addr);
299         if (sciErr.iErr)
300         {
301             printError(&sciErr, 0);
302             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
303             FREE(pStVarOne);
304             return 0;
305         }
306
307         if (!isDoubleType(pvApiCtx, addr))
308         {
309             Scierror(999, _("%s: Wrong type for input argument #%d: Double expected.\n"), fname, 4);
310             FREE(pStVarOne);
311             return 0;
312         }
313
314         sciErr = getMatrixOfDouble(pvApiCtx, addr, &iRows, &iCols, &colsIndex);
315         if (sciErr.iErr)
316         {
317             FREE(pStVarOne);
318             printError(&sciErr, 0);
319             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
320             return 0;
321         }
322
323         nbColsIndex = iRows * iCols;
324     }
325
326     //org_modules_commons::ScilabToJava::sendVariable(std::string(pStVarOne), true, pvApiCtx);
327
328     /* get type of the named variable */
329     sciErr = getVarType(pvApiCtx, piAddr, &iType);
330     if (sciErr.iErr)
331     {
332         FREE(pStVarOne);
333         printError(&sciErr, 0);
334         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
335         return 0;
336     }
337
338     switch (iType)
339     {
340         case sci_matrix :
341
342             /* get complexity */
343             iComplex    = isVarComplex(pvApiCtx, piAddr);
344
345             /* check complexity */
346             if (iComplex)
347             {
348                 /* get size and data from Scilab memory */
349                 sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
350                 if (sciErr.iErr)
351                 {
352                     FREE(pStVarOne);
353                     printError(&sciErr, 0);
354                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
355                     return 0;
356                 }
357
358                 ppdblRealMatrix = wrap<double, double>(pdblReal, iRows, iCols);
359                 ppdblImgMatrix = wrap<double, double>(pdblImg, iRows, iCols);
360
361                 try
362                 {
363                     if (nbRowsIndex == 0 || nbColsIndex == 0)
364                     {
365                         /* Launch Java Variable Editor through JNI */
366                         EditVar::openVariableEditorComplex(getScilabJavaVM(),
367                                                            ppdblRealMatrix,
368                                                            iRows,
369                                                            iCols,
370                                                            ppdblImgMatrix,
371                                                            iRows,
372                                                            iCols,
373                                                            pStVarOne);
374                     }
375                     else
376                     {
377                         /* Launch Java Variable Editor through JNI */
378                         EditVar::refreshVariableEditorComplex(getScilabJavaVM(),
379                                                               ppdblRealMatrix,
380                                                               iRows,
381                                                               iCols,
382                                                               ppdblImgMatrix,
383                                                               iRows,
384                                                               iCols,
385                                                               rowsIndex,
386                                                               nbRowsIndex,
387                                                               colsIndex,
388                                                               nbColsIndex,
389                                                               pStVarOne);
390                     }
391                 }
392                 catch (const GiwsException::JniException & e)
393                 {
394                     Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
395                 }
396
397                 clearWrap<double>(ppdblRealMatrix, iRows);
398                 clearWrap<double>(ppdblImgMatrix, iRows);
399             }
400             else
401             {
402                 /* get size and data from Scilab memory */
403                 sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
404                 if (sciErr.iErr)
405                 {
406                     FREE(pStVarOne);
407                     printError(&sciErr, 0);
408                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
409                     return 0;
410                 }
411                 /*
412                  * we need this to make the links between the API (which return a double*)
413                  * and the JNI which needs a double**
414                  */
415                 ppdblRealMatrix = wrap<double, double>(pdblReal, iRows, iCols);
416
417                 /* Launch Java Variable Editor through JNI */
418                 try
419                 {
420                     if (nbRowsIndex == 0 || nbColsIndex == 0)
421                     {
422                         EditVar::openVariableEditorDouble(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, pStVarOne);
423                     }
424                     else
425                     {
426                         EditVar::refreshVariableEditorDouble(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
427                     }
428                 }
429                 catch (const GiwsException::JniException & e)
430                 {
431                     Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
432                 }
433
434                 clearWrap<double>(ppdblRealMatrix, iRows);
435             }
436             break;
437
438         case sci_strings :
439
440             //retrieve data
441             if (getAllocatedMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, &pstData))
442             {
443                 FREE(pStVarOne);
444                 printError(&sciErr, 0);
445                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
446                 return 0;
447             }
448
449             /*
450              * we need this to make the links between the API (which return a char**)
451              * and the JNI which needs a 2-dims char*
452              */
453             ppstData = wrap<char *, char *>(pstData, iRows, iCols);
454
455             /* Launch Java Variable Editor through JNI */
456             try
457             {
458                 if (nbRowsIndex == 0 || nbColsIndex == 0)
459                 {
460                     EditVar::openVariableEditorString(getScilabJavaVM(), ppstData, iRows, iCols, pStVarOne);
461                 }
462                 else
463                 {
464                     EditVar::refreshVariableEditorString(getScilabJavaVM(), ppstData, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
465                 }
466             }
467             catch (const GiwsException::JniException & e)
468             {
469                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
470             }
471
472             freeAllocatedMatrixOfString(iRows, iCols, pstData);
473
474             clearWrap<char *>(ppstData, iRows);
475
476             break;
477
478         case sci_boolean :
479             //get size and data from Scilab memory
480             sciErr = getMatrixOfBoolean(pvApiCtx, piAddr, &iRows, &iCols, &piBool);
481             if (sciErr.iErr)
482             {
483                 FREE(pStVarOne);
484                 printError(&sciErr, 0);
485                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
486                 return 0;
487             }
488
489             /*
490              * we need this to make the links between the API (which return a int*)
491              * and the JNI which needs a int**
492              */
493             ppiBool = wrap<int, int>(piBool, iRows, iCols);
494
495             /* Launch Java Variable Editor through JNI */
496             try
497             {
498                 if (nbRowsIndex == 0 || nbColsIndex == 0)
499                 {
500                     EditVar::openVariableEditorBoolean(getScilabJavaVM(), ppiBool, iRows, iCols, pStVarOne);
501                 }
502                 else
503                 {
504                     EditVar::refreshVariableEditorBoolean(getScilabJavaVM(), ppiBool, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
505                 }
506             }
507             catch (const GiwsException::JniException & e)
508             {
509                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
510             }
511
512             clearWrap<int>(ppiBool, iRows);
513
514             break;
515
516         case sci_ints :
517             //get size and data from Scilab memory
518             int prec;
519             sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr, &prec);
520             if (sciErr.iErr)
521             {
522                 FREE(pStVarOne);
523                 printError(&sciErr, 0);
524                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
525                 return 0;
526             }
527
528             switch (prec)
529             {
530                 case SCI_INT8 :
531                     sciErr = getMatrixOfInteger8(pvApiCtx, piAddr, &iRows, &iCols, &piInt8);
532                     if (sciErr.iErr)
533                     {
534                         printError(&sciErr, 0);
535                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
536                         return -1;
537                     }
538
539                     ppiInt8 = wrap<char, char>(piInt8, iRows, iCols);
540
541                     /* Launch Java Variable Editor through JNI */
542                     try
543                     {
544                         if (nbRowsIndex == 0 || nbColsIndex == 0)
545                         {
546                             EditVar::openVariableEditorInteger8(getScilabJavaVM(), reinterpret_cast<byte**>(ppiInt8), iRows, iCols, pStVarOne);
547                         }
548                         else
549                         {
550                             EditVar::refreshVariableEditorInteger8(getScilabJavaVM(), reinterpret_cast<byte**>(ppiInt8), iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
551                         }
552                     }
553                     catch (const GiwsException::JniException & e)
554                     {
555                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
556                     }
557
558                     clearWrap<char>(ppiInt8, iRows);
559
560                     break;
561
562                 case SCI_UINT8 :
563                     sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddr, &iRows, &iCols, &piUInt8);
564                     if (sciErr.iErr)
565                     {
566                         printError(&sciErr, 0);
567                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
568                         return -1;
569                     }
570
571                     ppiUInt8 = wrap<short, unsigned char>(piUInt8, iRows, iCols);
572
573                     /* Launch Java Variable Editor through JNI */
574                     try
575                     {
576                         if (nbRowsIndex == 0 || nbColsIndex == 0)
577                         {
578                             EditVar::openVariableEditorUInteger8(getScilabJavaVM(), ppiUInt8, iRows, iCols, pStVarOne);
579                         }
580                         else
581                         {
582                             EditVar::refreshVariableEditorUInteger8(getScilabJavaVM(), ppiUInt8, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
583                         }
584                     }
585                     catch (const GiwsException::JniException & e)
586                     {
587                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
588                     }
589
590                     clearWrap<short>(ppiUInt8, iRows);
591
592                     break;
593
594                 case SCI_INT16 :
595                     sciErr = getMatrixOfInteger16(pvApiCtx, piAddr, &iRows, &iCols, &piInt16);
596                     if (sciErr.iErr)
597                     {
598                         printError(&sciErr, 0);
599                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
600                         return -1;
601                     }
602
603                     ppiInt16 = wrap<short, short>(piInt16, iRows, iCols);
604
605                     /* Launch Java Variable Editor through JNI */
606                     try
607                     {
608                         if (nbRowsIndex == 0 || nbColsIndex == 0)
609                         {
610                             EditVar::openVariableEditorInteger16(getScilabJavaVM(), ppiInt16, iRows, iCols, pStVarOne);
611                         }
612                         else
613                         {
614                             EditVar::refreshVariableEditorInteger16(getScilabJavaVM(), ppiInt16, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
615                         }
616                     }
617                     catch (const GiwsException::JniException & e)
618                     {
619                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
620                     }
621
622                     clearWrap<short>(ppiInt16, iRows);
623
624                     break;
625
626                 case SCI_UINT16 :
627                     sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddr, &iRows, &iCols, &piUInt16);
628                     if (sciErr.iErr)
629                     {
630                         printError(&sciErr, 0);
631                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
632                         return -1;
633                     }
634
635                     ppiUInt16 = wrap<int, unsigned short>(piUInt16, iRows, iCols);
636
637                     /* Launch Java Variable Editor through JNI */
638                     try
639                     {
640                         if (nbRowsIndex == 0 || nbColsIndex == 0)
641                         {
642                             EditVar::openVariableEditorUInteger16(getScilabJavaVM(), ppiUInt16, iRows, iCols, pStVarOne);
643                         }
644                         else
645                         {
646                             EditVar::refreshVariableEditorUInteger16(getScilabJavaVM(), ppiUInt16, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
647                         }
648                     }
649                     catch (const GiwsException::JniException & e)
650                     {
651                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
652                     }
653
654                     clearWrap<int>(ppiUInt16, iRows);
655
656                     break;
657
658                 case SCI_INT32 :
659                     sciErr = getMatrixOfInteger32(pvApiCtx, piAddr, &iRows, &iCols, &piInt32);
660                     if (sciErr.iErr)
661                     {
662                         printError(&sciErr, 0);
663                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
664                         return -1;
665                     }
666
667                     ppiInt32 = wrap<int>(piInt32, iRows, iCols);
668
669                     /* Launch Java Variable Editor through JNI */
670                     try
671                     {
672                         if (nbRowsIndex == 0 || nbColsIndex == 0)
673                         {
674                             EditVar::openVariableEditorInteger32(getScilabJavaVM(), ppiInt32, iRows, iCols, pStVarOne);
675                         }
676                         else
677                         {
678                             EditVar::refreshVariableEditorInteger32(getScilabJavaVM(), ppiInt32, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
679                         }
680                     }
681                     catch (const GiwsException::JniException & e)
682                     {
683                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
684                     }
685
686                     clearWrap<int>(ppiInt32, iRows);
687
688                     break;
689
690                 case SCI_UINT32 :
691                     sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddr, &iRows, &iCols, &piUInt32);
692                     if (sciErr.iErr)
693                     {
694                         printError(&sciErr, 0);
695                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
696                         return -1;
697                     }
698
699                     ppiUInt32 = wrap<long long int, unsigned int>(piUInt32, iRows, iCols);
700
701                     /* Launch Java Variable Editor through JNI */
702                     try
703                     {
704                         if (nbRowsIndex == 0 || nbColsIndex == 0)
705                         {
706                             EditVar::openVariableEditorUInteger32(getScilabJavaVM(), ppiUInt32, iRows, iCols, pStVarOne);
707                         }
708                         else
709                         {
710                             EditVar::refreshVariableEditorUInteger32(getScilabJavaVM(), ppiUInt32, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
711                         }
712                     }
713                     catch (const GiwsException::JniException & e)
714                     {
715                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
716                     }
717
718                     clearWrap<long long int>(ppiUInt32, iRows);
719
720                     break;
721
722                 default :
723
724                     Scierror(42, _("%s: Type not handle yet"), fname);
725                     return 0;
726             }
727
728             break;
729
730         case sci_boolean_sparse :
731             sciErr = getBooleanSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos);
732             if (sciErr.iErr)
733             {
734                 FREE(pStVarOne);
735                 printError(&sciErr, 0);
736                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
737                 return 0;
738             }
739
740             ppiBool = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols);
741
742             /* Launch Java Variable Editor through JNI */
743             try
744             {
745                 if (nbRowsIndex == 0 || nbColsIndex == 0)
746                 {
747                     EditVar::openVariableEditorBooleanSparse(getScilabJavaVM(), ppiBool, iRows, iCols, pStVarOne);
748                 }
749                 else
750                 {
751                     EditVar::refreshVariableEditorBooleanSparse(getScilabJavaVM(), ppiBool, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
752                 }
753             }
754             catch (const GiwsException::JniException & e)
755             {
756                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
757             }
758
759             clearWrap<int>(ppiBool, iRows);
760             break;
761         case sci_sparse :
762             if (isVarComplex(pvApiCtx, piAddr))
763             {
764                 sciErr = getComplexSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
765                 if (sciErr.iErr)
766                 {
767                     FREE(pStVarOne);
768                     printError(&sciErr, 0);
769                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
770                     return 0;
771                 }
772
773                 ppdblRealMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblReal);
774                 ppdblImgMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblImg);
775
776                 /* Launch Java Variable Editor through JNI */
777                 try
778                 {
779                     if (nbRowsIndex == 0 || nbColsIndex == 0)
780                     {
781                         EditVar::openVariableEditorComplexSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, ppdblImgMatrix, iRows, iCols, pStVarOne);
782                     }
783                     else
784                     {
785                         EditVar::refreshVariableEditorComplexSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, ppdblImgMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
786                     }
787                 }
788                 catch (const GiwsException::JniException & e)
789                 {
790                     Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
791                 }
792
793                 clearWrap<double>(ppdblRealMatrix, iRows);
794                 clearWrap<double>(ppdblImgMatrix, iRows);
795             }
796             else
797             {
798                 sciErr = getSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos, &pdblReal);
799                 if (sciErr.iErr)
800                 {
801                     FREE(pStVarOne);
802                     printError(&sciErr, 0);
803                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
804                     return 0;
805                 }
806
807                 ppdblRealMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblReal);
808
809                 /* Launch Java Variable Editor through JNI */
810                 try
811                 {
812                     if (nbRowsIndex == 0 || nbColsIndex == 0)
813                     {
814                         EditVar::openVariableEditorSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, pStVarOne);
815                     }
816                     else
817                     {
818                         EditVar::refreshVariableEditorSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
819                     }
820                 }
821                 catch (const GiwsException::JniException & e)
822                 {
823                     Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
824                 }
825
826                 clearWrap<double>(ppdblRealMatrix, iRows);
827             }
828             break;
829         default:
830
831             Scierror(42, _("%s: Type not handle yet"), fname);
832             return 0;
833     }
834
835     FREE(pStVarOne);
836
837     LhsVar(1) = 0;
838     PutLhsVar();
839     return 0;
840 }
841 /*--------------------------------------------------------------------------*/