bug_14204: fix swap of error messages in dec2base
[scilab.git] / scilab / modules / elementary_functions / sci_gateway / c / sci_dec2base.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2011 - DIGITEO - Allan CORNET
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 #include <math.h>
14 #include "gw_elementary_functions.h"
15 #include "sci_malloc.h"
16 #include "api_scilab.h"
17 #include "Scierror.h"
18 #include "localization.h"
19 #include "convertbase.h"
20 #include "freeArrayOfString.h"
21 /*--------------------------------------------------------------------------*/
22 int sci_dec2base(char *fname, void* pvApiCtx)
23 {
24     SciErr sciErr;
25     int *piAddressVarOne = NULL;
26     int *piAddressVarTwo = NULL;
27     int m = 0, n = 0;
28
29     double *dValues = NULL;
30     char **convertedValues = NULL;
31     unsigned int iBaseUsed = 0;
32     double dBaseUsed = 0.;
33     unsigned int nbDigits = 0;
34     error_convertbase err = ERROR_CONVERTBASE_NOK;
35
36     CheckInputArgument(pvApiCtx, 2, 3);
37     CheckOutputArgument(pvApiCtx, 1, 1);
38
39     if (nbInputArgument(pvApiCtx) == 3)
40     {
41         double dParamThree = 0.;
42         unsigned int iParamThree = 0;
43         int *piAddressVarThree = NULL;
44         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
45         if (sciErr.iErr)
46         {
47             printError(&sciErr, 0);
48             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
49             return 1;
50         }
51
52         if (!isDoubleType(pvApiCtx, piAddressVarThree))
53         {
54             Scierror(999, _("%s: Wrong type for input argument #%d: A scalar integer value expected.\n"), fname, 3);
55             return 1;
56         }
57
58         if (!isScalar(pvApiCtx, piAddressVarThree))
59         {
60             Scierror(999, _("%s: Wrong size for input argument #%d: A scalar integer value expected.\n"), fname, 3);
61             return 1;
62         }
63
64         if (getScalarDouble(pvApiCtx, piAddressVarThree, &dParamThree) != 0)
65         {
66             Scierror(999, _("%s: No more memory.\n"), fname);
67             return 1;
68         }
69
70         iParamThree = (unsigned int)dParamThree;
71
72         if (dParamThree != (double)iParamThree)
73         {
74             Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), fname, 3);
75             return 1;
76         }
77
78         nbDigits = iParamThree;
79     }
80
81     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
82     if (sciErr.iErr)
83     {
84         printError(&sciErr, 0);
85         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
86         return 1;
87     }
88
89     if (!isDoubleType(pvApiCtx, piAddressVarTwo))
90     {
91         Scierror(999, _("%s: Wrong type for input argument #%d: An integer value expected.\n"), fname, 2);
92         return 1;
93     }
94
95     if (!isScalar(pvApiCtx, piAddressVarTwo))
96     {
97         Scierror(999, _("%s: Wrong size for input argument #%d.\n"), fname, 2);
98         return 1;
99     }
100
101     if (getScalarDouble(pvApiCtx, piAddressVarTwo, &dBaseUsed) != 0)
102     {
103         Scierror(999, _("%s: No more memory.\n"), fname);
104         return 1;
105     }
106
107     iBaseUsed = (unsigned int)dBaseUsed;
108     if (dBaseUsed != (double)iBaseUsed)
109     {
110         Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), fname, 2);
111         return 1;
112     }
113
114     if (iBaseUsed < 2 || iBaseUsed > 36)
115     {
116         Scierror(999, _("%s: Wrong value for input argument #%d: Must be between %d and %d."), fname, 2, 2, 36);
117         return 1;
118     }
119
120     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
121     if (sciErr.iErr)
122     {
123         printError(&sciErr, 0);
124         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
125         return 1;
126     }
127
128     if (isEmptyMatrix(pvApiCtx, piAddressVarOne))
129     {
130         if (createEmptyMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1) != 0)
131         {
132             Scierror(999, _("%s: No more memory.\n"), fname);
133             return 1;
134         }
135         else
136         {
137             AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
138             ReturnArguments(pvApiCtx);
139             return 0;
140         }
141     }
142
143     if (!isDoubleType(pvApiCtx, piAddressVarOne))
144     {
145         Scierror(999, _("%s: Wrong type for input argument #%d: A matrix of integer value expected.\n"), fname, 1);
146         return 1;
147     }
148
149     if (isVarComplex(pvApiCtx, piAddressVarOne))
150     {
151         Scierror(999, _("%s: Wrong type for input argument #%d: A matrix of integer value expected.\n"), fname, 1);
152         return 1;
153     }
154
155     sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &m, &n , &dValues);
156     if (sciErr.iErr)
157     {
158         printError(&sciErr, 0);
159         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
160         return 1;
161     }
162
163     convertedValues = convertMatrixOfDec2Base(dValues, m * n, iBaseUsed, nbDigits, &err);
164     if ((err != ERROR_CONVERTBASE_OK) || (convertedValues == NULL))
165     {
166         freeArrayOfString(convertedValues, m * n);
167         convertedValues = NULL;
168
169         switch (err)
170         {
171             case ERROR_CONVERTBASE_NOT_INTEGER_VALUE:
172                 Scierror(999, _("%s: Wrong value(s) for input argument #%d: A matrix of positive integer values expected.\n"), fname, 1);
173                 return 1;
174
175             case ERROR_CONVERTBASE_NOT_IN_INTERVAL:
176                 Scierror(999, _("%s: Wrong value for input argument #%d: Must be between 0 and 2^52.\n"), fname, 1);
177                 return 1;
178
179             case ERROR_CONVERTBASE_ALLOCATION:
180                 Scierror(999, _("%s: No more memory.\n"), fname);
181                 return 1;
182
183             case ERROR_CONVERTBASE_NOK:
184             default:
185                 Scierror(999, _("%s: Wrong value for input argument #%d: cannot convert value(s).\n"), fname, 1);
186                 return 1;
187         }
188     }
189
190     sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m, n, (char const * const*) convertedValues);
191     freeArrayOfString(convertedValues, m * n);
192     convertedValues = NULL;
193
194     if (sciErr.iErr)
195     {
196         printError(&sciErr, 0);
197         Scierror(999, _("%s: Memory allocation error.\n"), fname);
198         return 1;
199     }
200
201     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
202     ReturnArguments(pvApiCtx);
203     return 0;
204 }
205 /*--------------------------------------------------------------------------*/