Coverity: Matio module memory leaks fixed
[scilab.git] / scilab / modules / matio / sci_gateway / c / sci_matfile_open.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2014 - Scilab Enterprises - Paul Bignier: bug #13102 fixed
4  * Copyright (C) 2008 - INRIA - Vincent COUVERT
5  * Copyright (C) 2010 - DIGITEO - Yann COLLETTE
6  *
7  * Copyright (C) 2012 - 2016 - Scilab Enterprises
8  *
9  * This file is hereby licensed under the terms of the GNU GPL v2.0,
10  * pursuant to article 5.3.4 of the CeCILL v.2.1.
11  * This file was originally licensed under the terms of the CeCILL v2.1,
12  * and continues to be available under such terms.
13  * For more information, see the COPYING file which you should have received
14  * along with this program.
15  *
16  */
17
18 #include "api_scilab.h"
19 #include "sci_malloc.h"
20 #include "matfile_manager.h"
21 #include "gw_matio.h"
22 #include "localization.h"
23 #include "Scierror.h"
24 #include <string.h>
25
26 /*******************************************************************************
27    Interface for MATIO function called Mat_Open
28    Scilab function name : matfile_open
29 *******************************************************************************/
30 int sci_matfile_open(char *fname, void* pvApiCtx)
31 {
32     int nbRow = 0, nbCol = 0;
33     mat_t *matfile;
34     int fileIndex = 0;
35     char * filename  = NULL;
36     char * optionStr = NULL;
37     int option = 0, var_type;
38     int * filename_addr = NULL, * option_addr = NULL, * version_addr = NULL;
39     char * versionStr = NULL;
40     int version = MAT_FT_MAT5; // By default, use MAtlab 5 files
41     SciErr sciErr;
42
43     CheckRhs(1, 3);
44     CheckLhs(1, 1);
45
46     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &filename_addr);
47     if (sciErr.iErr)
48     {
49         printError(&sciErr, 0);
50         return 0;
51     }
52     sciErr = getVarType(pvApiCtx, filename_addr, &var_type);
53     if (sciErr.iErr)
54     {
55         printError(&sciErr, 0);
56         return 0;
57     }
58
59     if (var_type == sci_strings)
60     {
61         if (getAllocatedSingleString(pvApiCtx, filename_addr, &filename) != 0)
62         {
63             return 0;
64         }
65         sciErr = getVarDimension(pvApiCtx, filename_addr, &nbRow, &nbCol);
66         if (sciErr.iErr)
67         {
68             printError(&sciErr, 0);
69             freeAllocatedSingleString(filename);
70             return 0;
71         }
72
73         if (nbCol != 1)
74         {
75             Scierror(999, _("%s: Wrong size for first input argument: string expected.\n"), fname);
76             freeAllocatedSingleString(filename);
77             return FALSE;
78         }
79     }
80     else
81     {
82         Scierror(999, _("%s: Wrong type for first input argument: string expected.\n"), fname);
83         freeAllocatedSingleString(filename);
84         return FALSE;
85     }
86
87     if (Rhs >= 2)
88     {
89         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &option_addr);
90         if (sciErr.iErr)
91         {
92             printError(&sciErr, 0);
93             freeAllocatedSingleString(filename);
94             return 0;
95         }
96
97         sciErr = getVarType(pvApiCtx, option_addr, &var_type);
98         if (sciErr.iErr)
99         {
100             printError(&sciErr, 0);
101             freeAllocatedSingleString(filename);
102             return 0;
103         }
104
105         if (var_type == sci_strings)
106         {
107             if (getAllocatedSingleString(pvApiCtx, option_addr, &optionStr) != 0)
108             {
109                 freeAllocatedSingleString(filename);
110                 return 0;
111             }
112             sciErr = getVarDimension(pvApiCtx, option_addr, &nbRow, &nbCol);
113             if (sciErr.iErr)
114             {
115                 printError(&sciErr, 0);
116                 freeAllocatedSingleString(filename);
117                 freeAllocatedSingleString(optionStr);
118                 return 0;
119             }
120
121             if (nbCol != 1)
122             {
123                 Scierror(999, _("%s: Wrong size for second input argument: string expected.\n"), fname);
124                 freeAllocatedSingleString(filename);
125                 freeAllocatedSingleString(optionStr);
126
127                 return FALSE;
128             }
129
130             if (strcmp(optionStr, "r") == 0)
131             {
132                 option = MAT_ACC_RDONLY;
133             }
134             else if (strcmp(optionStr, "w") == 0)
135             {
136                 option = MAT_ACC_RDWR;
137             }
138             else
139             {
140                 Scierror(999, _("%s: Wrong value for second input argument: 'r' or 'w' expected.\n"), fname);
141                 freeAllocatedSingleString(filename);
142                 freeAllocatedSingleString(optionStr);
143
144                 return FALSE;
145             }
146         }
147         else
148         {
149             Scierror(999, _("%s: Wrong type for second input argument: string expected.\n"), fname);
150             freeAllocatedSingleString(filename);
151             freeAllocatedSingleString(optionStr);
152
153             return FALSE;
154         }
155     }
156     else
157     {
158         /* Default option value */
159         option = MAT_ACC_RDONLY;
160     }
161
162     if (Rhs >= 3)
163     {
164         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &version_addr);
165         if (sciErr.iErr)
166         {
167             printError(&sciErr, 0);
168             freeAllocatedSingleString(filename);
169             freeAllocatedSingleString(optionStr);
170             return 0;
171         }
172
173         sciErr = getVarType(pvApiCtx, version_addr, &var_type);
174         if (sciErr.iErr)
175         {
176             printError(&sciErr, 0);
177             freeAllocatedSingleString(filename);
178             freeAllocatedSingleString(optionStr);
179             return 0;
180         }
181         printf("sci_strings %d %d\n", var_type, sci_strings);
182         if (var_type == sci_strings)
183         {
184             if (getAllocatedSingleString(pvApiCtx, version_addr, &versionStr) != 0)
185             {
186                 freeAllocatedSingleString(filename);
187                 freeAllocatedSingleString(optionStr);
188                 return 0;
189             }
190             sciErr = getVarDimension(pvApiCtx, version_addr, &nbRow, &nbCol);
191             if (sciErr.iErr)
192             {
193                 printError(&sciErr, 0);
194                 freeAllocatedSingleString(filename);
195                 freeAllocatedSingleString(optionStr);
196                 freeAllocatedSingleString(versionStr);
197                 return 0;
198             }
199             if (nbCol != 1)
200             {
201                 Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 3);
202                 freeAllocatedSingleString(filename);
203                 freeAllocatedSingleString(optionStr);
204                 freeAllocatedSingleString(versionStr);
205
206                 return FALSE;
207             }
208
209             if (strcmp(versionStr, "7.3") == 0)
210             {
211                 version = MAT_FT_MAT73; // Matlab 7.3 file
212             }
213             else
214             {
215                 version = MAT_FT_MAT5; // Default, Matlab 5 file
216             }
217         }
218         else
219         {
220             Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 3);
221             freeAllocatedSingleString(filename);
222             freeAllocatedSingleString(optionStr);
223             return 0;
224         }
225     }
226
227     if (option == MAT_ACC_RDWR) // Write, option = "w"
228     {
229         /* create a Matlab 5 or 7.3 file */
230         matfile = Mat_CreateVer(filename, NULL, version);
231     }
232     else // Read, option = "r"
233     {
234         /* Try to open the file (as a Matlab 5 file) */
235         matfile = Mat_Open(filename, option);
236     }
237
238     if (matfile == NULL) /* Opening failed */
239     {
240         /* Function returns -1 */
241         fileIndex = -1;
242     }
243
244     if (matfile != NULL) /* Opening succeed */
245     {
246         /* Add the file to the manager */
247         matfile_manager(MATFILEMANAGER_ADDFILE, &fileIndex, &matfile);
248     }
249
250     /* Return the index */
251     createScalarDouble(pvApiCtx, Rhs + 1, (double)fileIndex);
252
253     freeAllocatedSingleString(filename);
254     freeAllocatedSingleString(optionStr);
255     freeAllocatedSingleString(versionStr);
256
257     LhsVar(1) = Rhs + 1;
258     PutLhsVar();
259
260     return TRUE;
261 }