* Bug #13298 fixed - Static analysis bugs detected by PVS-Studio fixed
[scilab.git] / scilab / modules / gui / sci_gateway / cpp / sci_toprint.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) INRIA - Allan CORNET
4  * Copyright (C) 2008 - INRIA - Vincent COUVERT (Java version)
5  * Copyright (C) 2011 - DIGITEO - Allan CORNET
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
12  *
13 */
14
15 /*--------------------------------------------------------------------------*/
16 #include "CallScilabBridge.hxx"
17 #include "GiwsException.hxx"
18
19 extern "C"
20 {
21 #include "api_scilab.h"
22 #include "sci_malloc.h"
23 #include "sciprint.h"
24 #include "Scierror.h"
25 #include "FileExist.h"
26 #include "freeArrayOfString.h"
27 #include "localization.h"
28 #include "gw_gui.h"
29 #include "getScilabJavaVM.h"
30 #include "getFullFilename.h"
31 #include "loadOnUseClassPath.h"
32 #include "configvariable_interface.h"
33 #include "FigureList.h"
34 }
35 /*--------------------------------------------------------------------------*/
36 static BOOL loadedDep = FALSE;
37
38 /*--------------------------------------------------------------------------*/
39 using namespace org_scilab_modules_gui_bridge;
40
41 /*--------------------------------------------------------------------------*/
42 static int sci_toprint_one_rhs(void* _pvCtx, const char *fname);
43 static int sci_toprint_two_rhs(void* _pvCtx, const char *fname);
44 /*--------------------------------------------------------------------------*/
45 int sci_toprint(char *fname, void* pvApiCtx)
46 {
47     CheckInputArgument(pvApiCtx, 1, 2);
48     CheckOutputArgument(pvApiCtx, 0, 1);
49
50     if (!loadedDep)
51     {
52         loadOnUseClassPath("pdf_ps_eps_graphic_export");
53         loadedDep = TRUE;
54     }
55
56     if (nbInputArgument(pvApiCtx) == 1)
57     {
58         return sci_toprint_one_rhs(pvApiCtx, fname);
59     }
60     else
61     {
62         return sci_toprint_two_rhs(pvApiCtx, fname);
63     }
64     return 0;
65 }
66
67 /*--------------------------------------------------------------------------*/
68 static int sci_toprint_one_rhs(void* _pvCtx, const char *fname)
69 {
70     SciErr sciErr;
71     int *piAddressVarOne = NULL;
72
73     sciErr = getVarAddressFromPosition(_pvCtx, 1, &piAddressVarOne);
74     if (sciErr.iErr)
75     {
76         printError(&sciErr, 0);
77         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
78         return 1;
79     }
80
81     if (isStringType(_pvCtx, piAddressVarOne))
82     {
83         char *fileName = NULL;
84         BOOL iRet = FALSE;
85
86         if (getAllocatedSingleString(_pvCtx, piAddressVarOne, &fileName) == 0)
87         {
88             char *fullName = getFullFilename(fileName);
89
90             freeAllocatedSingleString(fileName);
91             if (fullName)
92             {
93                 if (FileExist(fullName))
94                 {
95                     try
96                     {
97                         iRet = booltoBOOL(CallScilabBridge::printFile(getScilabJavaVM(), fullName));
98                     }
99                     catch (const GiwsException::JniException & e)
100                     {
101                         FREE(fullName);
102                         fullName = NULL;
103                         Scierror(999, _("%s: An exception occurred: %s\n%s\n"), fname, e.getJavaDescription().c_str(),
104                                  e.getJavaExceptionName().c_str());
105                         return 1;
106                     }
107                 }
108                 else
109                 {
110                     if (getWarningMode())
111                     {
112                         sciprint(_("%s: The file %s does not exist.\n"), fname, fullName);
113                     }
114                     iRet = FALSE;
115                 }
116                 FREE(fullName);
117                 fullName = NULL;
118             }
119
120             createScalarBoolean(_pvCtx, nbInputArgument(_pvCtx) + 1, iRet);
121             AssignOutputVariable(_pvCtx, 1) = nbInputArgument(_pvCtx) + 1;
122             ReturnArguments(_pvCtx);
123             return 0;
124         }
125         else
126         {
127             Scierror(999, _("%s: Memory allocation error.\n"), fname);
128         }
129     }
130     else if (isDoubleType(_pvCtx, piAddressVarOne))
131     {
132         if (isScalar(_pvCtx, piAddressVarOne))
133         {
134             double dValue = 0.;
135
136             if (!getScalarDouble(_pvCtx, piAddressVarOne, &dValue))
137             {
138                 int num_win = (int)dValue;
139                 BOOL iRet = FALSE;
140
141                 if (num_win < 0)
142                 {
143                     Scierror(999, _("%s: Wrong value for input argument #%d: Positive integers expected.\n"), fname);
144                     return 1;
145                 }
146
147                 if (getFigureFromIndex((int) num_win) == NULL)
148                 {
149                     Scierror(999, "%s: Figure with figure_id %d does not exist.\n", fname, (int)num_win);
150                     return 1;
151                 }
152
153                 try
154                 {
155                     iRet = booltoBOOL(CallScilabBridge::printFigure(getScilabJavaVM(), getFigureFromIndex((int) num_win), FALSE, FALSE));
156                 }
157                 catch (const GiwsException::JniException & e)
158                 {
159                     Scierror(999, _("%s: An exception occurred: %s\n%s\n"), fname, e.getJavaDescription().c_str(), e.getJavaExceptionName().c_str());
160                     return 1;
161                 }
162
163                 createScalarBoolean(_pvCtx, nbInputArgument(_pvCtx) + 1, iRet);
164                 AssignOutputVariable(_pvCtx, 1) = nbInputArgument(_pvCtx) + 1;
165                 ReturnArguments(_pvCtx);
166                 return 0;
167             }
168             else
169             {
170                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
171             }
172         }
173         else
174         {
175             Scierror(999, _("%s: Wrong size for input argument #%d: Positive integer expected.\n"), fname, 1);
176         }
177     }
178     else
179     {
180         Scierror(999, _("%s: Wrong type for input argument #%d.\n"), fname, 1);
181     }
182     return 1;
183 }
184
185 /*--------------------------------------------------------------------------*/
186 static int sci_toprint_two_rhs(void* _pvCtx, const char *fname)
187 {
188     SciErr sciErr;
189     int *piAddressVarOne = NULL;
190     int *piAddressVarTwo = NULL;
191
192     sciErr = getVarAddressFromPosition(_pvCtx, 1, &piAddressVarOne);
193     if (sciErr.iErr)
194     {
195         printError(&sciErr, 0);
196         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
197         return 1;
198     }
199
200     sciErr = getVarAddressFromPosition(_pvCtx, 2, &piAddressVarTwo);
201     if (sciErr.iErr)
202     {
203         printError(&sciErr, 0);
204         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
205         return 1;
206     }
207
208     if (isStringType(_pvCtx, piAddressVarOne))
209     {
210         if (isScalar(_pvCtx, piAddressVarTwo))
211         {
212             if (isStringType(_pvCtx, piAddressVarTwo))
213             {
214                 char *pageHeader = NULL;
215                 char **pStVarOne = NULL;
216                 int *lenStVarOne = NULL;
217                 int mOne = 0, nOne = 0;
218                 int mnOne = 0;
219                 int lenLineToPrint = 0;
220                 int i = 0;
221                 char *lines = NULL;
222
223                 sciErr = getMatrixOfString(_pvCtx, piAddressVarOne, &mOne, &nOne, NULL, NULL);
224                 if (sciErr.iErr)
225                 {
226                     printError(&sciErr, 0);
227                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
228                     return 1;
229                 }
230
231                 if (!((mOne == 1) || (nOne == 1)))
232                 {
233                     Scierror(999, _("%s: Wrong size for input argument #%d: A 1-by-n or m-by-1 array expected.\n"), fname, 1);
234                     return 1;
235                 }
236
237                 mnOne = mOne * nOne;
238
239                 lenStVarOne = (int *)MALLOC(sizeof(int) * mnOne);
240                 if (lenStVarOne == NULL)
241                 {
242                     Scierror(999, _("%s: No more memory.\n"), fname);
243                     return 1;
244                 }
245
246                 sciErr = getMatrixOfString(_pvCtx, piAddressVarOne, &mOne, &nOne, lenStVarOne, NULL);
247                 if (sciErr.iErr)
248                 {
249                     printError(&sciErr, 0);
250                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
251                     return 1;
252                 }
253
254                 for (i = 0; i < mnOne; i++)
255                 {
256                     lenLineToPrint = lenLineToPrint + lenStVarOne[i] + (int)strlen("\n") + 1;
257                 }
258
259                 pStVarOne = (char **)MALLOC(sizeof(char *) * mnOne);
260                 if (pStVarOne == NULL)
261                 {
262                     FREE(lenStVarOne);
263                     lenStVarOne = NULL;
264                     Scierror(999, _("%s: No more memory.\n"), fname);
265                     return 1;
266                 }
267
268                 for (i = 0; i < mnOne; i++)
269                 {
270                     pStVarOne[i] = (char *)MALLOC(sizeof(char) * (lenStVarOne[i] + 1));
271                     if (pStVarOne[i] == NULL)
272                     {
273                         freeArrayOfString(pStVarOne, i);
274                         if (lenStVarOne)
275                         {
276                             FREE(lenStVarOne);
277                             lenStVarOne = NULL;
278                         }
279                         Scierror(999, _("%s: No more memory.\n"), fname);
280                         return 1;
281                     }
282                 }
283
284                 sciErr = getMatrixOfString(_pvCtx, piAddressVarOne, &mOne, &nOne, lenStVarOne, pStVarOne);
285                 if (lenStVarOne)
286                 {
287                     FREE(lenStVarOne);
288                     lenStVarOne = NULL;
289                 }
290                 if (sciErr.iErr)
291                 {
292                     freeArrayOfString(pStVarOne, mnOne);
293                     printError(&sciErr, 0);
294                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
295                     return 1;
296                 }
297
298                 lines = (char *)MALLOC((lenLineToPrint + 1) * sizeof(char));
299                 if (lines == NULL)
300                 {
301                     freeArrayOfString(pStVarOne, mnOne);
302                     Scierror(999, _("%s: No more memory.\n"), fname);
303                     return 1;
304                 }
305
306                 if (mnOne > 0)
307                 {
308                     sprintf(lines, "%s\n", pStVarOne[0]);
309                     for (i = 1; i < mnOne; ++i)
310                     {
311                         sprintf(lines, "%s%s\n", lines, pStVarOne[i]);
312                     }
313                 }
314                 freeArrayOfString(pStVarOne, mnOne);
315
316                 if (getAllocatedSingleString(_pvCtx, piAddressVarTwo, &pageHeader) == 0)
317                 {
318                     BOOL iRet = FALSE;
319
320                     try
321                     {
322                         iRet = booltoBOOL(CallScilabBridge::printString(getScilabJavaVM(), lines, pageHeader));
323                     }
324
325                     catch (const GiwsException::JniException & e)
326                     {
327                         freeAllocatedSingleString(pageHeader);
328                         if (lines)
329                         {
330                             FREE(lines);
331                             lines = NULL;
332                         }
333                         Scierror(999, _("%s: An exception occurred: %s\n%s\n"), fname, e.getJavaDescription().c_str(),
334                                  e.getJavaExceptionName().c_str());
335                         return 1;
336                     }
337
338                     freeAllocatedSingleString(pageHeader);
339                     if (lines)
340                     {
341                         FREE(lines);
342                         lines = NULL;
343                     }
344
345                     createScalarBoolean(_pvCtx, nbInputArgument(_pvCtx) + 1, iRet);
346                     AssignOutputVariable(_pvCtx, 1) = nbInputArgument(_pvCtx) + 1;
347                     ReturnArguments(_pvCtx);
348                     return 0;
349                 }
350                 else
351                 {
352                     if (lines)
353                     {
354                         FREE(lines);
355                         lines = NULL;
356                     }
357                     Scierror(999, _("%s: Memory allocation error.\n"), fname);
358                 }
359             }
360             else
361             {
362                 Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 2);
363             }
364         }
365         else
366         {
367             Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname, 2);
368         }
369     }
370     else if (isDoubleType(_pvCtx, piAddressVarOne))
371     {
372         if (isScalar(_pvCtx, piAddressVarOne))
373         {
374             int num_win = 0;
375             double dValue = 0.;
376
377             if (!getScalarDouble(_pvCtx, piAddressVarOne, &dValue))
378             {
379                 num_win = (int)dValue;
380
381                 if (num_win < 0)
382                 {
383                     Scierror(999, _("%s: Wrong value for input argument #%d: Positive integers expected.\n"), fname);
384                     return 1;
385                 }
386             }
387             else
388             {
389                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
390                 return 1;
391             }
392
393             if (!sciIsExistingFigure((int)num_win))
394             {
395                 Scierror(999, "%s: Figure with figure_id %d does not exist.\n", fname, (int)num_win);
396                 return 1;
397             }
398
399             if (isStringType(_pvCtx, piAddressVarTwo))
400             {
401                 BOOL iRet = FALSE;
402
403                 if (isScalar(_pvCtx, piAddressVarTwo))
404                 {
405                     char *outputType = NULL;
406
407                     if (getAllocatedSingleString(_pvCtx, piAddressVarTwo, &outputType) == 0)
408                     {
409                         if ((strcmp(outputType, "pos") == 0) || (strcmp(outputType, "gdi") == 0))
410                         {
411                             try
412                             {
413                                 if (strcmp(outputType, "pos") == 0)
414                                 {
415                                     iRet = booltoBOOL(CallScilabBridge::printFigure(getScilabJavaVM(), getFigureFromIndex(num_win), TRUE, FALSE));
416                                 }
417                                 else
418                                 {
419                                     iRet = booltoBOOL((int)CallScilabBridge::printFigure(getScilabJavaVM(), getFigureFromIndex(num_win), FALSE, FALSE));
420                                 }
421                             }
422                             catch (const GiwsException::JniException & e)
423                             {
424                                 Scierror(999, _("%s: An exception occurred: %s\n%s\n"), fname, e.getJavaDescription().c_str(),
425                                          e.getJavaExceptionName().c_str());
426                                 freeAllocatedSingleString(outputType);
427                                 return 1;
428                             }
429
430                             createScalarBoolean(_pvCtx, nbInputArgument(_pvCtx) + 1, iRet);
431                             AssignOutputVariable(_pvCtx, 1) = nbInputArgument(_pvCtx) + 1;
432                             ReturnArguments(_pvCtx);
433                             return 0;
434                         }
435                         else
436                         {
437                             Scierror(999, _("%s: Wrong input argument #%d: '%s' or '%s' expected.\n"), fname, 2, "pos", "gdi");
438                         }
439                         freeAllocatedSingleString(outputType);
440                     }
441                     else
442                     {
443                         Scierror(999, _("%s: Memory allocation error.\n"), fname);
444                     }
445                 }
446                 else
447                 {
448                     Scierror(999, _("%s: Wrong size for input argument #%d: 'pos' or 'gdi' value expected.\n"), fname, 2);
449                 }
450             }
451             else
452             {
453                 Scierror(999, _("%s: Wrong type for input argument #%d.\n"), fname, 2);
454             }
455         }
456         else
457         {
458             Scierror(999, _("%s: Wrong size for input argument #%d: Positive integer expected.\n"), fname, 1);
459         }
460     }
461     else
462     {
463         Scierror(999, _("%s: Wrong type for input argument #%d.\n"), fname, 1);
464     }
465     return 1;
466 }
467
468 /*--------------------------------------------------------------------------*/