Fix bugs in mget/mput with integer 32 (follow I0f8609105b450a05489c230a6196c95bbf10677b)
[scilab.git] / scilab / modules / fileio / src / c / mget.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2007 - INRIA
4  * ...
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13 /*--------------------------------------------------------------------------*/
14 #include <string.h>
15 #ifndef _MSC_VER
16 #include <stdint.h>
17 #endif
18 #include "mget.h"
19 #include "filesmanagement.h"
20 #include "sciprint.h"
21 #include "islittleendian.h"
22 #include "convert_tools.h"
23 #include "localization.h"
24 /*--------------------------------------------------------------------------*/
25 int swap = 0;
26
27 /*--------------------------------------------------------------------------*/
28 /* =================================================
29 * reads data and store them without type conversion
30 * =================================================*/
31 /*--------------------------------------------------------------------------*/
32 #define MGET_CHAR_NC(Type)                                       \
33   {                                                                               \
34     Type *val = (Type *) res ;                                  \
35     items=(int)fread(val,sizeof(Type),n,fa);    \
36   }
37
38 /*--------------------------------------------------------------------------*/
39 #define MGET_NC(Type) {                                                           \
40     Type *val = (Type *) res ;                                                    \
41     if (swap) {                                                                            \
42       items=0;                                                                                \
43       for ( i=0; i< n; i++)  {                                                    \
44               unsigned long long tmp;                                                     \
45               items+=(int)fread(&tmp,sizeof(Type),1,fa);                      \
46               swap_generic((char *)&tmp,(char *)val, sizeof(Type));     \
47               val++;                                                                               \
48       }                                                                                          \
49     }                                                                                               \
50     else items=(int)fread(val,sizeof(Type),n,fa);                        \
51   }
52 /*--------------------------------------------------------------------------*/
53 #define MGET_GEN_NC(NumType,cf)                    \
54   {                                                                            \
55     switch (cf) {                                                        \
56     case ' ':                                                            \
57       MGET_NC(NumType);break;                                   \
58     case 'b':                                                      \
59       swap = (islittleendian()==1)? 1:0;  \
60     MGET_NC(NumType); break;                                    \
61     case 'l':                                                            \
62       swap = (islittleendian()==1) ? 0:1; \
63     MGET_NC(NumType);  break;                                   \
64     default:                                                       \
65       sciprint(_("%s: Wrong value for input argument #%d: '%s' or '%s' or '%s' expected.\n"),"mget",4," ","b","l"); \
66       *ierr=1; return;                                             \
67     }                                                                          \
68 }
69 /*--------------------------------------------------------------------------*/
70 void C2F(mgetnc) (int *fd, void *res, int *n1, char *type, int *ierr)
71 {
72     char c1, c2;
73     int i, items, n = *n1;
74     FILE *fa;
75
76     *ierr = 0;
77     if ((fa = GetFileOpenedInScilab(*fd)) == NULL)
78     {
79         sciprint(_("%s: No input file associated to logical unit %d.\n"), "mget", *fd);
80         *ierr = 3;
81         return;
82     }
83     swap = GetSwapStatus(*fd);
84     c1 = (strlen(type) > 1) ? type[1] : ' ';
85     c2 = (strlen(type) > 2) ? type[2] : ' ';
86     switch (type[0])
87     {
88         case 'i':
89             MGET_GEN_NC(int, c1);
90             break;
91
92         case 'l':
93             MGET_GEN_NC(long long, c1);
94             break;
95
96         case 's':
97             MGET_GEN_NC(short, c1);
98             break;
99
100         case 'c':
101             MGET_CHAR_NC(char);
102             break;
103
104         case 'd':
105             MGET_GEN_NC(double, c1);
106             break;
107
108         case 'f':
109             MGET_GEN_NC(float, c1);
110             break;
111
112         case 'u':
113             switch (c1)
114             {
115                 case 'i':
116                     MGET_GEN_NC(unsigned int, c2);
117                     break;
118
119                 case 'l':
120                     MGET_GEN_NC(unsigned long long, c2);
121                     break;
122
123                 case 's':
124                     MGET_GEN_NC(unsigned short, c2);
125                     break;
126
127                 case ' ':
128                     MGET_GEN_NC(unsigned int, ' ');
129                     break;
130
131                 case 'c':
132                     MGET_CHAR_NC(unsigned char);
133                     break;
134
135                 default:
136                     *ierr = 1;
137                     return;
138             }
139             break;
140         default:
141             *ierr = 1;
142             return;
143     }
144     if (items != n)
145     {
146         *ierr = -(items) - 1;
147         /** sciprint("Read %d out of\n",items,n); **/
148     }
149     return;
150 }
151
152 /*--------------------------------------------------------------------------*/
153 /* =================================================
154 * reads data and store them in double
155 * =================================================*/
156
157 /* conversion macro  */
158 #define CONVGD(Type)                            \
159   {                                             \
160     Type *val = (Type *) res ;                  \
161     for ( i = items-1 ; i >=0 ; i--)            \
162       res[i] = val[i];                          \
163   }
164 /*--------------------------------------------------------------------------*/
165 #define MGET_GEN(NumType,cf)  MGET_GEN_NC(NumType,cf); CONVGD(NumType);
166 #define MGET_CHAR(NumType)    MGET_CHAR_NC(NumType);   CONVGD(NumType);
167 /*--------------------------------------------------------------------------*/
168 /* reads data and store them in double  */
169 void mget2(FILE * fa, int swap2, double *res, int n, char *type, int *ierr)
170 {
171     char c1, c2;
172     int i, items = n;
173
174     *ierr = 0;
175     c1 = (strlen(type) > 1) ? type[1] : ' ';
176     c2 = (strlen(type) > 2) ? type[2] : ' ';
177     switch (type[0])
178     {
179         case 'i':
180             MGET_GEN(int, c1);
181             break;
182
183         case 'l':
184             MGET_GEN(long long, c1);
185             break;
186
187         case 's':
188             MGET_GEN(short, c1);
189             break;
190
191         case 'c':
192             MGET_CHAR(char);
193             break;
194
195         case 'd':
196             MGET_GEN(double, c1);
197             break;
198
199         case 'f':
200             MGET_GEN(float, c1);
201             break;
202
203         case 'u':
204             switch (c1)
205             {
206                 case 'i':
207                     MGET_GEN(unsigned int, c2);
208                     break;
209
210                 case 'l':
211                     MGET_GEN(unsigned long long, c2);
212                     break;
213
214                 case 's':
215                     MGET_GEN(unsigned short, c2);
216                     break;
217
218                 case ' ':
219                     MGET_GEN(unsigned int, ' ');
220                     break;
221
222                 case 'c':
223                     MGET_CHAR(unsigned char);
224                     break;
225
226                 default:
227                     *ierr = 1;
228                     return;
229             }
230             break;
231         default:
232             *ierr = 1;
233             return;
234     }
235     if (items != n)
236     {
237         *ierr = -(items) - 1;
238         /** sciprint("Read %d out of\n",items,n); **/
239     }
240     return;
241 }
242
243 /*--------------------------------------------------------------------------*/
244 void C2F(mget) (int *fd, double *res, int *n, char *type, int *ierr)
245 {
246     int nc, swap2;
247     FILE *fa;
248
249     nc = (int)strlen(type);
250     *ierr = 0;
251     if (nc == 0)
252     {
253         sciprint(_("%s: Wrong size for input argument #%d: Non-empty string expected.\n"), "mput", 4, type);
254         *ierr = 2;
255         return;
256     }
257     fa = GetFileOpenedInScilab(*fd);
258     if (fa)
259     {
260         swap2 = GetSwapStatus(*fd);
261         mget2(fa, swap2, res, *n, type, ierr);
262         if (*ierr > 0)
263         {
264             sciprint(_("%s: Wrong value for input argument #%d: Format not recognized.\n"), "mget", 4);
265         }
266     }
267     else
268     {
269         sciprint(_("%s: No input file associated to logical unit %d.\n"), "mget", *fd);
270         *ierr = 3;
271     }
272 }
273
274 /*--------------------------------------------------------------------------*/