Fix Coverity issues introduced by https://codereview.scilab.org/#/c/13430/ ...
[scilab.git] / scilab / modules / string / sci_gateway / c / sci_convstr.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) INRIA - Cong WU
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
10  *
11  */
12
13 /* desc : converts the matrix of strings  str-matrix  into lower case (for*/
14 /*          "l"  ;default value) or upper case (for  "u" ).               */
15 /*        [y]=convstr(str-matrix, ["flag"])                               */
16 /*              str-matrix, y : matrices of strings                       */
17 /*              "flag"  : string ( "u"  for upper or  "l"  for lower      */
18 /*                        (default value))                                */
19 /*------------------------------------------------------------------------*/
20 #include <string.h>
21 #include <stdio.h>
22 #include "gw_string.h"
23 #include "api_scilab.h"
24 #include "MALLOC.h"
25 #include "wchar.h"
26 #include "convstr.h"
27 #include "localization.h"
28 #include "Scierror.h"
29 #include "freeArrayOfString.h"
30 /*----------------------------------------------------------------------------*/
31 int sci_convstr(char *fname, unsigned long fname_len)
32 {
33     SciErr sciErr;
34     wchar_t **pstInput = NULL;
35     wchar_t **pstOutput = NULL;
36     char cType = LOW;
37     int iRows1 = 0;
38     int iCols1 = 0;
39     int i = 0;
40
41     int* piAddr1 = NULL;
42
43     int* piAddr2 = NULL;
44
45     int iRhs = nbInputArgument(pvApiCtx);
46     CheckInputArgument(pvApiCtx, 1, 2);
47     CheckOutputArgument(pvApiCtx, 1, 1);
48
49
50     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
51     if (sciErr.iErr)
52     {
53         printError(&sciErr, 0);
54         return 0;
55     }
56
57
58     if (isEmptyMatrix(pvApiCtx, piAddr1))
59     {
60         if (createEmptyMatrix(pvApiCtx, Rhs + 1))
61         {
62             Scierror(999, _("%s: Memory allocation error.\n"), fname);
63             return 0;
64         }
65
66         AssignOutputVariable(pvApiCtx, 1) = iRhs + 1 ;
67         ReturnArguments(pvApiCtx);
68         return 0;
69     }
70
71     if (iRhs == 2)
72     {
73         char* pstFlag = NULL;
74
75         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
76         if (sciErr.iErr)
77         {
78             printError(&sciErr, 0);
79             return 0;
80         }
81
82         if (isStringType(pvApiCtx, piAddr2) && isScalar(pvApiCtx, piAddr2) == 0)
83         {
84             Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
85             return 0;
86         }
87
88         /* To put "flag" into typ; whether "u" or "l" */
89         if (getAllocatedSingleString(pvApiCtx, piAddr2, &pstFlag))
90         {
91             freeAllocatedSingleString(pstFlag);
92             Scierror(999, _("%s: Memory allocation error.\n"), fname);
93             return 0;
94         }
95
96         if (strlen(pstFlag) != 1 || (pstFlag[0] != UPPER && pstFlag[0] != LOW && pstFlag[0] != UPPER_B && pstFlag[0] != LOW_B ))
97         {
98             freeAllocatedSingleString(pstFlag);
99             Scierror(999, _("%s: Wrong value for input argument #%d: 'u' (Upper) or 'l' (Lower) expected.\n"), fname, 2);
100             return 0;
101         }
102
103         cType = pstFlag[0];
104         freeAllocatedSingleString(pstFlag);
105     }
106
107     if (isStringType(pvApiCtx, piAddr1) == 0)
108     {
109         Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 1);
110         return 0;
111     }
112
113     /* To input the string matrix */
114     if (getAllocatedMatrixOfWideString(pvApiCtx, piAddr1, &iRows1, &iCols1, &pstInput))
115     {
116         freeAllocatedMatrixOfWideString(iRows1, iCols1, pstInput);
117         Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 1);
118         return 0;
119     }
120
121     pstOutput = (wchar_t**)MALLOC(sizeof(wchar_t*) * iRows1 * iCols1);
122     if (pstOutput == NULL)
123     {
124         freeAllocatedMatrixOfWideString(iRows1, iCols1, pstInput);
125         Scierror(999, _("%s: No more memory.\n"), fname);
126         return 0;
127     }
128
129     for (i = 0; i < iRows1 * iCols1; i++)
130     {
131         pstOutput[i] = (wchar_t*)MALLOC(sizeof(wchar_t) * (wcslen(pstInput[i]) + 1));
132         if (pstOutput[i] == NULL)
133         {
134             freeAllocatedMatrixOfWideString(iRows1, iCols1, pstInput);
135             freeArrayOfWideString(pstOutput, i);
136             Scierror(999, ("%s: No more memory.\n"), fname);
137             return 0;
138         }
139     }
140
141     /* convstr algorithm */
142     convstr(pstInput, pstOutput, cType, iRows1 * iCols1);
143     freeAllocatedMatrixOfWideString(iRows1, iCols1, pstInput);
144
145     /* put on scilab stack */
146     sciErr = createMatrixOfWideString(pvApiCtx, iRhs + 1, iRows1, iCols1, (const wchar_t**)pstOutput);
147     freeArrayOfWideString(pstOutput, iRows1 * iCols1);
148
149     if (sciErr.iErr)
150     {
151         printError(&sciErr, 0);
152         Scierror(999, _("%s: Memory allocation error.\n"), fname);
153         return 0;
154     }
155
156     AssignOutputVariable(pvApiCtx, 1) = iRhs + 1 ;
157     ReturnArguments(pvApiCtx);
158     return 0;
159 }
160 /*--------------------------------------------------------------------------*/