mseek parameter offset passed as double for file size more than 2GB.
[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.1-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, const 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     /* Safe version for optional type modifiers */
85     c1 = (type[0] && type[1]) ? type[1] : ' ';
86     c2 = (type[0] && type[1] && type[2]) ? type[2] : ' ';
87     switch (type[0])
88     {
89         case 'i':
90             MGET_GEN_NC(int, c1);
91             break;
92
93         case 'l':
94             MGET_GEN_NC(long long, c1);
95             break;
96
97         case 's':
98             MGET_GEN_NC(short, c1);
99             break;
100
101         case 'c':
102             MGET_CHAR_NC(char);
103             break;
104
105         case 'd':
106             MGET_GEN_NC(double, c1);
107             break;
108
109         case 'f':
110             MGET_GEN_NC(float, c1);
111             break;
112
113         case 'u':
114             switch (c1)
115             {
116                 case 'i':
117                     MGET_GEN_NC(unsigned int, c2);
118                     break;
119
120                 case 'l':
121                     MGET_GEN_NC(unsigned long long, c2);
122                     break;
123
124                 case 's':
125                     MGET_GEN_NC(unsigned short, c2);
126                     break;
127
128                 case ' ':
129                     MGET_GEN_NC(unsigned int, ' ');
130                     break;
131
132                 case 'c':
133                     MGET_CHAR_NC(unsigned char);
134                     break;
135
136                 default:
137                     *ierr = 1;
138                     return;
139             }
140             break;
141         default:
142             *ierr = 1;
143             return;
144     }
145     if (items != n)
146     {
147         *ierr = -(items) - 1;
148         /** sciprint("Read %d out of\n",items,n); **/
149     }
150     return;
151 }
152
153 /*--------------------------------------------------------------------------*/
154 /* =================================================
155 * reads data and store them in double
156 * =================================================*/
157
158 /* conversion macro  */
159 #define CONVGD(Type)                            \
160   {                                             \
161     Type *val = (Type *) res ;                  \
162     for ( i = items-1 ; i >=0 ; i--)            \
163       res[i] = val[i];                          \
164   }
165 /*--------------------------------------------------------------------------*/
166 #define MGET_GEN(NumType,cf)  MGET_GEN_NC(NumType,cf); CONVGD(NumType);
167 #define MGET_CHAR(NumType)    MGET_CHAR_NC(NumType);   CONVGD(NumType);
168 /*--------------------------------------------------------------------------*/
169 /* reads data and store them in double  */
170 void mget2(FILE * fa, int swap2, double *res, int n, const char *type, int *ierr)
171 {
172     char c1, c2;
173     int i, items = n;
174
175     *ierr = 0;
176     c1 = (strlen(type) > 1) ? type[1] : ' ';
177     c2 = (strlen(type) > 2) ? type[2] : ' ';
178     switch (type[0])
179     {
180         case 'i':
181             MGET_GEN(int, c1);
182             break;
183
184         case 'l':
185             MGET_GEN(long long, c1);
186             break;
187
188         case 's':
189             MGET_GEN(short, c1);
190             break;
191
192         case 'c':
193             MGET_CHAR(char);
194             break;
195
196         case 'd':
197             MGET_GEN(double, c1);
198             break;
199
200         case 'f':
201             MGET_GEN(float, c1);
202             break;
203
204         case 'u':
205             switch (c1)
206             {
207                 case 'i':
208                     MGET_GEN(unsigned int, c2);
209                     break;
210
211                 case 'l':
212                     MGET_GEN(unsigned long long, c2);
213                     break;
214
215                 case 's':
216                     MGET_GEN(unsigned short, c2);
217                     break;
218
219                 case ' ':
220                     MGET_GEN(unsigned int, ' ');
221                     break;
222
223                 case 'c':
224                     MGET_CHAR(unsigned char);
225                     break;
226
227                 default:
228                     *ierr = 1;
229                     return;
230             }
231             break;
232         default:
233             *ierr = 1;
234             return;
235     }
236     if (items != n)
237     {
238         *ierr = -(items) - 1;
239         /** sciprint("Read %d out of\n",items,n); **/
240     }
241     return;
242 }
243
244 /*--------------------------------------------------------------------------*/
245 void C2F(mget) (int *fd, double *res, int *n, const char *type, int *ierr)
246 {
247     int nc, swap2;
248     FILE *fa;
249
250     nc = (int)strlen(type);
251     *ierr = 0;
252     if (nc == 0)
253     {
254         sciprint(_("%s: Wrong size for input argument #%d: Non-empty string expected.\n"), "mput", 4, type);
255         *ierr = 2;
256         return;
257     }
258     fa = GetFileOpenedInScilab(*fd);
259     if (fa)
260     {
261         swap2 = GetSwapStatus(*fd);
262         mget2(fa, swap2, res, *n, type, ierr);
263         if (*ierr > 0)
264         {
265             sciprint(_("%s: Wrong value for input argument #%d: Format not recognized.\n"), "mget", 4);
266         }
267     }
268     else
269     {
270         sciprint(_("%s: No input file associated to logical unit %d.\n"), "mget", *fd);
271         *ierr = 3;
272     }
273 }
274
275 /*--------------------------------------------------------------------------*/