Coverity: Matio module memory leaks fixed
[scilab.git] / scilab / modules / matio / sci_gateway / c / sci_matfile_varwrite.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2008 - INRIA - Vincent COUVERT
4  * Copyright (C) 2010 - DIGITEO - Yann COLLETTE
5  *
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  */
16
17 #include "gw_matio.h"
18 #include "GetMatlabVariable.h"
19 #include "api_scilab.h"
20
21 enum matfile_errors
22 {
23     NO_MORE_VARIABLES = -1,
24     UNKNOWN_VARIABLE_TYPE = 0
25 };
26
27 int sci_matfile_varwrite(char *fname, void* pvApiCtx)
28 {
29     int nbRow = 0, nbCol = 0;
30     mat_t *matfile = NULL;
31     matvar_t *matvar = NULL;
32     int fileIndex = 0;
33     char *varname = NULL;
34     int flag = 0;
35     int compressionFlag = 0;
36     int var_type;
37     int * fd_addr = NULL, * name_addr = NULL, * cp_flag_addr = NULL;
38     double tmp_dbl;
39     SciErr sciErr;
40
41     CheckRhs(4, 4);
42     CheckLhs(1, 1);
43
44     /* Input argument is the index of the file to write */
45
46     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &fd_addr);
47     if (sciErr.iErr)
48     {
49         printError(&sciErr, 0);
50         return 0;
51     }
52     sciErr = getVarType(pvApiCtx, fd_addr, &var_type);
53     if (sciErr.iErr)
54     {
55         printError(&sciErr, 0);
56         return 0;
57     }
58
59     if (var_type == sci_matrix)
60     {
61         getScalarDouble(pvApiCtx, fd_addr, &tmp_dbl);
62         if (!isScalar(pvApiCtx, fd_addr))
63         {
64             Scierror(999, _("%s: Wrong size for first input argument: An integer value expected.\n"), fname);
65             return FALSE;
66         }
67         fileIndex = (int)tmp_dbl;
68     }
69     else
70     {
71         Scierror(999, _("%s: Wrong type for first input argument: An integer value expected.\n"), fname);
72         return FALSE;
73     }
74
75     /* Gets the corresponding matfile */
76     matfile_manager(MATFILEMANAGER_GETFILE, &fileIndex, &matfile);
77
78     /* Second argument is the variable name */
79
80     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &name_addr);
81     if (sciErr.iErr)
82     {
83         printError(&sciErr, 0);
84         return 0;
85     }
86     sciErr = getVarType(pvApiCtx, name_addr, &var_type);
87     if (sciErr.iErr)
88     {
89         printError(&sciErr, 0);
90         return 0;
91     }
92
93     if (var_type == sci_strings)
94     {
95         if (getAllocatedSingleString(pvApiCtx, name_addr, &varname) != 0)
96         {
97             return 0;
98         }
99         sciErr = getVarDimension(pvApiCtx, name_addr, &nbRow, &nbCol);
100         if (sciErr.iErr)
101         {
102             printError(&sciErr, 0);
103             freeAllocatedSingleString(varname);
104             return 0;
105         }
106         if (nbCol != 1)
107         {
108             Scierror(999, _("%s: Wrong size for second input argument: string expected.\n"), fname);
109
110             freeAllocatedSingleString(varname);
111
112             return FALSE;
113         }
114     }
115     else
116     {
117         Scierror(999, _("%s: Wrong type for second input argument: string expected.\n"), fname);
118
119         freeAllocatedSingleString(varname);
120
121         return FALSE;
122     }
123
124     /* Third argument is the variable data */
125     /* TODO update this NULL */
126     matvar = GetMatlabVariable(pvApiCtx, 3, varname, Mat_GetVersion(matfile), NULL, -1);
127
128     /* Fourth argument is the compression flag */
129
130     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &cp_flag_addr);
131     if (sciErr.iErr)
132     {
133         printError(&sciErr, 0);
134         return 0;
135     }
136     sciErr = getVarType(pvApiCtx, cp_flag_addr, &var_type);
137     if (sciErr.iErr)
138     {
139         printError(&sciErr, 0);
140         return 0;
141     }
142
143     if (var_type == sci_boolean)
144     {
145         getScalarBoolean(pvApiCtx, cp_flag_addr, &compressionFlag);
146         if (!isScalar(pvApiCtx, cp_flag_addr))
147         {
148             Scierror(999, _("%s: Wrong size for fourth input argument: A boolean expected.\n"), fname);
149
150             freeAllocatedSingleString(varname);
151
152             return FALSE;
153         }
154     }
155     else
156     {
157         Scierror(999, _("%s: Wrong type for fourth input argument: A boolean expected.\n"), fname);
158
159         freeAllocatedSingleString(varname);
160
161         return FALSE;
162     }
163
164     flag = Mat_VarWrite(matfile, matvar, compressionFlag);
165
166     /* Return execution flag */
167     var_type = (flag == 0);
168     createScalarBoolean(pvApiCtx, Rhs + 1, var_type);
169
170     freeAllocatedSingleString(varname);
171     LhsVar(1) = Rhs + 1;
172     PutLhsVar();
173
174     return TRUE;
175 }