Coverity fixes : CID #1098655 #1098654 #1098652
[scilab.git] / scilab / modules / gui / sci_gateway / cpp / sci_uiputfile.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2009 - DIGITEO - Vincent COUVERT
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
16 /*------------------------------------------------------------------------*/
17 /* file: sci_uiputfile.cpp                                                */
18 /* desc : interface for uiputfile routine                                 */
19 /*------------------------------------------------------------------------*/
20 #include "CallJuigetfile.hxx"
21 #include "GiwsException.hxx"
22
23 extern "C"
24 {
25 #include <string.h>
26 #include <stdio.h>
27 #include "gw_gui.h"
28 #include "PATH_MAX.h"
29 #include "api_scilab.h"
30 #include "sci_malloc.h"
31 #include "localization.h"
32 #include "Scierror.h"
33 #include "expandPathVariable.h"
34 #include "freeArrayOfString.h"
35 #include "os_string.h"
36 #include "BOOL.h"
37 }
38 using namespace org_scilab_modules_gui_filechooser;
39
40 static int deleteArrayOfString(char **Str, int dim)
41 {
42     int ret = 1;
43
44     if(Str)
45     {
46         int i = 0;
47         for(i = 0; i < dim; i++)
48         {
49             if(Str[i])
50             {
51                 delete Str[i];
52                 Str[i] = NULL;
53             }
54             else
55             {
56                 ret = 0;
57             }
58         }
59         delete[] Str;
60         Str = NULL;
61
62     }
63     else
64     {
65         ret = 0;
66     }
67
68     return ret;
69 }
70
71 /*--------------------------------------------------------------------------*/
72
73 int sci_uiputfile(char *fname, void* pvApiCtx)
74 {
75     SciErr sciErr;
76
77     int nbRow  = 0, nbCol  = 0;
78     int nbRow2 = 0, nbCol2 = 0;
79     int nbRow3 = 0, nbCol3 = 0;
80     int ret = 0;
81
82     int nbRowOutSelection = 1, nbColOutSelection = 0;
83     int nbRowOutFilterIndex = 1, nbColOutFilterIndex = 1;
84     int nbRowOutPath = 1, nbColOutPath = 1;
85
86     char** mask = NULL;
87     char** description = NULL;
88
89     char* titleBox = NULL;
90     char* selectionPathName = NULL;
91     char* initialDirectory = NULL;
92
93     int multipleSelection = 0;
94
95     char **selection = NULL;
96     char **selectionFileNames = NULL;
97     int selectionSize = 0;
98     int filterIndex = 0;
99
100     char *menuCallback = NULL;
101
102     int* piAddr1 = NULL;
103     int* piAddr2 = NULL;
104     int* piAddr3 = NULL;
105
106     CheckInputArgument(pvApiCtx, 0, 3);
107     CheckOutputArgument(pvApiCtx, 1, 3);
108
109     //inputs checking
110     /* call uiputfile with 1 arg */
111     if (nbInputArgument(pvApiCtx) >= 1)
112     {
113         if (checkInputArgumentType(pvApiCtx, 1, sci_strings) == FALSE)
114         {
115             Scierror(999, _("%s: Wrong type for input argument #%d: A string matrix expected.\n"), fname, 1);
116             return 1;
117         }
118
119         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
120         if (sciErr.iErr)
121         {
122             printError(&sciErr, 0);
123             return 1;
124         }
125
126         if (getAllocatedMatrixOfString(pvApiCtx, piAddr1, &nbRow, &nbCol, &mask))
127         {
128             printError(&sciErr, 0);
129             return 1;
130         }
131
132         if (nbCol == 1)
133         {
134             // only masks of files are provided
135             description = NULL;
136         }
137         else if (nbCol == 2)
138         {
139             // mask contains both the masks for files and the description of each mask
140             // in the sequence [m1, m2,..., mn, d1, d2,...,dn].
141             // So description is at the middle of the array.
142             description = (char **)MALLOC(sizeof(char *) * nbRow);
143             for (int i = 0; i < nbRow; i++)
144             {
145                 description[i] = os_strdup(mask[nbRow + i]);
146             }
147         }
148         else
149         {
150             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
151             Scierror(999, _("%s: Wrong size for input argument #%d: A string matrix expected.\n"), fname, 1);
152             return 1;
153         }
154     }
155
156     /* call uiputfile with 2 arg */
157     if (nbInputArgument(pvApiCtx) >= 2)
158     {
159         char *path = NULL;
160         if (checkInputArgumentType(pvApiCtx, 2, sci_strings) == FALSE)
161         {
162             freeArrayOfString(description, nbRow);
163             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
164             Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2);
165             return 1;
166         }
167
168         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
169         if (sciErr.iErr)
170         {
171             freeArrayOfString(description, nbRow);
172             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
173             printError(&sciErr, 0);
174             return 1;
175         }
176
177         if (getAllocatedSingleString(pvApiCtx, piAddr2, &initialDirectory))
178         {
179             freeArrayOfString(description, nbRow);
180             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
181             printError(&sciErr, 0);
182             return 1;
183         }
184
185         path = expandPathVariable(initialDirectory);
186         freeAllocatedSingleString(initialDirectory);
187         initialDirectory = path;
188     }
189
190     /* call uiputfile with 3 arg */
191     if (Rhs >= 3)
192     {
193         if (checkInputArgumentType(pvApiCtx, 3, sci_strings) == FALSE)
194         {
195             freeArrayOfString(description, nbRow);
196             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
197             freeAllocatedSingleString(initialDirectory);
198             Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 3);
199             return 1;
200         }
201
202         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
203         if (sciErr.iErr)
204         {
205             freeArrayOfString(description, nbRow);
206             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
207             freeAllocatedSingleString(initialDirectory);
208             printError(&sciErr, 0);
209             return 1;
210         }
211
212         if (getAllocatedSingleString(pvApiCtx, piAddr3, &titleBox))
213         {
214             freeArrayOfString(description, nbRow);
215             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
216             freeAllocatedSingleString(initialDirectory);
217             printError(&sciErr, 0);
218             return 1;
219         }
220     }
221
222     try
223     {
224         /* Call Java */
225         switch (nbInputArgument(pvApiCtx))
226         {
227             case 0:
228                 CallJuiputfileWithoutInput();
229                 break;
230
231             case 1:
232                 CallJuiputfileOnlyWithMask(mask, description, nbRow);
233                 break;
234
235             case 2:
236                 CallJuiputfileWithMaskAndInitialdirectory(mask, description, nbRow, initialDirectory);
237                 break;
238
239             case 3:
240                 CallJuiputfileWithoutMultipleSelection(mask, description, nbRow, initialDirectory, titleBox);
241                 break;
242
243             default:
244                 // never here
245                 break;
246         }
247
248         // free pointer
249         freeArrayOfString(description, nbRow);
250         freeAllocatedMatrixOfString(nbRow, nbCol, mask);
251         freeAllocatedSingleString(initialDirectory);
252         freeAllocatedSingleString(titleBox);
253
254         // Get return values
255         selection = getJuigetfileSelection();
256         selectionPathName = getJuigetfileSelectionPathName();
257         selectionFileNames = getJuigetfileSelectionFileNames();
258         selectionSize = getJuigetfileSelectionSize();
259         filterIndex = getJuigetfileFilterIndex();
260     }
261     catch (const GiwsException::JniException & e)
262     {
263         freeArrayOfString(description, nbRow);
264         freeAllocatedMatrixOfString(nbRow, nbCol, mask);
265         freeAllocatedSingleString(initialDirectory);
266         freeAllocatedSingleString(titleBox);
267         Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
268         return 1;
269     }
270
271     // nbColOutSelection
272     nbColOutSelection = selectionSize;
273
274     //if cancel is selected on the filechooser
275     if (strcmp(selection[0], "") == 0)
276     {
277         // "" is returned as filename
278         sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 1, selection);
279         if (sciErr.iErr)
280         {
281             printError(&sciErr, 0);
282             Scierror(999, _("%s: Memory allocation error.\n"), fname);
283             ret = deleteArrayOfString(selection, selectionSize);
284             ret = deleteArrayOfString(selectionFileNames, selectionSize);
285             if(selectionPathName)
286             {
287                 delete selectionPathName;
288                 selectionPathName = NULL;
289             }
290             return 1;
291         }
292
293         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
294
295         if (nbOutputArgument(pvApiCtx) > 1)
296         {
297             // "" is returned as pathname
298             sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 1, 1, selection);
299             if (sciErr.iErr)
300             {
301                 printError(&sciErr, 0);
302                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
303                 ret = deleteArrayOfString(selection, selectionSize);
304                 ret = deleteArrayOfString(selectionFileNames, selectionSize);
305                 if(selectionPathName)
306                 {
307                     delete selectionPathName;
308                     selectionPathName = NULL;
309                 }
310                 return 1;
311             }
312
313             AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
314         }
315
316         if (nbOutputArgument(pvApiCtx) > 2)
317         {
318             // 0 is returned as pathname
319             double tmp = 0;
320             sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, 1, 1, &tmp);
321             if (sciErr.iErr)
322             {
323                 printError(&sciErr, 0);
324                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
325                 ret = deleteArrayOfString(selection, selectionSize);
326                 ret = deleteArrayOfString(selectionFileNames, selectionSize);
327                 if(selectionPathName)
328                 {
329                     delete selectionPathName;
330                     selectionPathName = NULL;
331                 }
332                 return 1;
333             }
334
335             AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
336         }
337
338         ReturnArguments(pvApiCtx);
339         ret = deleteArrayOfString(selection, selectionSize);
340         ret = deleteArrayOfString(selectionFileNames, selectionSize);
341         if(selectionPathName)
342         {
343             delete selectionPathName;
344             selectionPathName = NULL;
345         }
346         return 0;
347     }
348
349     // Only one output then it contains path+filenames
350     if (nbOutputArgument(pvApiCtx) == 1)
351     {
352         sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowOutSelection, nbColOutSelection, selection);
353         if (sciErr.iErr)
354         {
355             printError(&sciErr, 0);
356             Scierror(999, _("%s: Memory allocation error.\n"), fname);
357             ret = deleteArrayOfString(selection, selectionSize);
358             ret = deleteArrayOfString(selectionFileNames, selectionSize);
359             if(selectionPathName)
360             {
361                 delete selectionPathName;
362                 selectionPathName = NULL;
363             }
364             return 1;
365         }
366
367         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
368         ReturnArguments(pvApiCtx);
369         ret = deleteArrayOfString(selection, selectionSize);
370         ret = deleteArrayOfString(selectionFileNames, selectionSize);
371         if(selectionPathName)
372         {
373             delete selectionPathName;
374             selectionPathName = NULL;
375         }
376         return 0;
377     }
378
379     // More than one output
380     sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowOutSelection, nbColOutSelection, selectionFileNames);
381     if (sciErr.iErr)
382     {
383         printError(&sciErr, 0);
384         Scierror(999, _("%s: Memory allocation error.\n"), fname);
385         ret = deleteArrayOfString(selection, selectionSize);
386         ret = deleteArrayOfString(selectionFileNames, selectionSize);
387         if(selectionPathName)
388         {
389             delete selectionPathName;
390             selectionPathName = NULL;
391         }
392         return 1;
393     }
394
395     if (createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 2, selectionPathName))
396     {
397         printError(&sciErr, 0);
398         ret = deleteArrayOfString(selection, selectionSize);
399         ret = deleteArrayOfString(selectionFileNames, selectionSize);
400         if(selectionPathName)
401         {
402             delete selectionPathName;
403             selectionPathName = NULL;
404         }
405         return 1;
406     }
407
408     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
409     AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
410
411     if (nbOutputArgument(pvApiCtx) > 2)
412     {
413         if (createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, filterIndex))
414         {
415             printError(&sciErr, 0);
416             ret = deleteArrayOfString(selection, selectionSize);
417             ret = deleteArrayOfString(selectionFileNames, selectionSize);
418             if(selectionPathName)
419             {
420                 delete selectionPathName;
421                 selectionPathName = NULL;
422             }
423             return 1;
424         }
425         AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
426     }
427
428     ReturnArguments(pvApiCtx);
429     ret = deleteArrayOfString(selection, selectionSize);
430     ret = deleteArrayOfString(selectionFileNames, selectionSize);
431     if(selectionPathName)
432     {
433         delete selectionPathName;
434         selectionPathName = NULL;
435     }
436     return 0;
437
438 }
439
440 /*--------------------------------------------------------------------------*/