12dfba12e776b892561df6e99d9ac9cda0b4d13e
[scilab.git] / scilab / modules / fileio / src / c / mput.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 "mput.h"
19 #include "filesmanagement.h"
20 #include "sciprint.h"
21 #include "islittleendian.h"
22 #include "convert_tools.h"
23 #include "localization.h"
24 #include "warningmode.h"
25 /*--------------------------------------------------------------------------*/
26 extern int swap; /* defined in mget.c */
27 /*--------------------------------------------------------------------------*/
28
29 /*===============================================
30  * function to write data without type conversion
31  *===============================================*/
32 #define MPUT_CHAR_NC(Type)                      \
33   {                                             \
34     Type *val = (Type *) res ;                  \
35     fwrite(val,sizeof(Type),n,fa);              \
36   }
37 /*--------------------------------------------------------------------------*/
38 #define MPUT_NC(Type) {                                 \
39     Type *val = (Type *) res ;                          \
40     if ( swap) {                                        \
41       unsigned long long temp;                          \
42       for ( i=0; i< n; i++) {                           \
43         swap_generic((char *)val,(char *)&temp, sizeof(Type));  \
44         val++;                                          \
45         fwrite(&temp,sizeof(Type),1,fa);                \
46       }                                                 \
47     }                                                   \
48     else fwrite(val,sizeof(Type),n,fa);                 \
49   }
50 /*--------------------------------------------------------------------------*/
51 #define MPUT_GEN_NC(Type,cf)                                            \
52   switch ( cf )                                                         \
53     {                                                                   \
54     case ' ':                                                           \
55       MPUT_NC(Type); break;                                             \
56     case 'b':                                                           \
57       swap = (islittleendian()==1) ? 1 : 0;                             \
58     MPUT_NC(Type); break;                                               \
59     case 'l':                                                           \
60       swap = (islittleendian()==1) ? 0 : 1;                             \
61     MPUT_NC(Type); break;                                               \
62     default:                                                            \
63       sciprint(_("%s: Wrong value for input argument #%d (%s): '%s' or '%s' or '%s' expected.\n"),"mput",4,type," ","b","l"); \
64       *ierr=1;return;                                                   \
65     }
66 /*--------------------------------------------------------------------------*/
67 /* write data without convertion (res is supposed to have type type) */
68 void C2F(mputnc) (int *fd, void * res, int *n1, char *type, int *ierr)
69 {
70     char c1, c2;
71     int i, n;
72     FILE *fa;
73     n = *n1;
74     *ierr = 0;
75     if ((fa = GetFileOpenedInScilab(*fd)) == NULL)
76     {
77         if ( getWarningMode() )
78         {
79             sciprint(_("%s: No input file associated to logical unit %d.\n"), "mput", *fd);
80         }
81         *ierr = 3;
82         return;
83     }
84
85     c1 = ( strlen(type) > 1) ? type[1] : ' ';
86     c2 = ( strlen(type) > 2) ? type[2] : ' ';
87     switch ( type[0] )
88     {
89         case 'i' :
90             MPUT_GEN_NC(long, c1);
91             break;
92         case 'l' :
93             MPUT_GEN_NC(long long, c1);
94             break;
95         case 's' :
96             MPUT_GEN_NC(short, c1);
97             break;
98         case 'c' :
99             MPUT_CHAR_NC(char) ;
100             break;
101         case 'd' :
102             MPUT_GEN_NC(double, c1);
103             break;
104         case 'f' :
105             MPUT_GEN_NC(float, c1);
106             break;
107         case 'u' :
108             switch ( c1 )
109             {
110                 case 'i' :
111                     MPUT_GEN_NC(unsigned long, c2);
112                     break;
113                 case 'l' :
114                     MPUT_GEN_NC(unsigned long long, c2);
115                     break;
116                 case 's' :
117                     MPUT_GEN_NC(unsigned short, c2);
118                     break;
119                 case ' ' :
120                     MPUT_GEN_NC(unsigned int, ' ');
121                     break;
122                 case 'c' :
123                     MPUT_CHAR_NC(unsigned char);
124                     break;
125                 default :
126                     *ierr = 1;
127                     return ;
128             }
129             break;
130         default :
131             *ierr = 1;
132             break;
133     }
134 }
135 /*--------------------------------------------------------------------------*/
136 /*================================================
137  * function to write data stored in double
138  *================================================*/
139 /** used for char **/
140 #define MPUT_CHAR(Type) {                       \
141     for ( i=0; i< n; i++) {                     \
142       Type  val = (char) *res++;                \
143       fwrite(&val,sizeof(Type),1,fa);           \
144     }                                           \
145   }
146 /*--------------------------------------------------------------------------*/
147 /** write in a machine independant way : i.e data
148     is swaped if necessary to output little-endian
149     data **/
150
151 #define MPUT(Type) {                                            \
152     Type val;                                                   \
153     for ( i=0; i< n; i++) {                                     \
154       val =(Type)res[i];                                        \
155       if ( swap) {                                              \
156         unsigned long long temp;                                \
157         swap_generic((char *)&val,(char *)&temp, sizeof(Type)); \
158         fwrite(&temp,sizeof(Type),1,fa);                        \
159       }                                                         \
160       else fwrite(&val,sizeof(Type),1,fa);                      \
161     }                                                           \
162   }
163
164 /*--------------------------------------------------------------------------*/
165 /** The output mode is controlled by type[1] **/
166 #define MPUT_GEN(Type,cf)                                               \
167   switch ( cf )                                                         \
168     {                                                                   \
169     case ' ':                                                           \
170       MPUT(Type); break;                                                \
171     case 'b':                                                           \
172       swap = (islittleendian()==1) ? 1 : 0;                             \
173     MPUT(Type); break;                                                  \
174     case 'l':                                                           \
175       swap = (islittleendian()==1) ? 0 : 1;                             \
176     MPUT(Type); break;                                                  \
177     default:                                                            \
178       if ( getWarningMode() ) sciprint(_("%s: Wrong value for input argument #%d (%s): '%s' or '%s' or '%s' expected.\n"),"mput",4,type," ","b","l"); \
179       *ierr=1;return;                                                   \
180     }
181 /*--------------------------------------------------------------------------*/
182 void mput2 (FILE *fa, int swap2, double *res, int n, char *type, int *ierr)
183 {
184     char c1, c2;
185     int i;
186     *ierr = 0;
187     c1 = ( strlen(type) > 1) ? type[1] : ' ';
188     c2 = ( strlen(type) > 2) ? type[2] : ' ';
189     switch ( type[0] )
190     {
191         case 'i' :
192             MPUT_GEN(long, c1);
193             break;
194         case 'l' :
195             MPUT_GEN(long long, c1);
196             break;
197         case 's' :
198             MPUT_GEN(short, c1);
199             break;
200         case 'c' :
201             MPUT_CHAR(char) ;
202             break;
203         case 'd' :
204             MPUT_GEN(double, c1);
205             break;
206         case 'f' :
207             MPUT_GEN(float, c1);
208             break;
209         case 'u' :
210             switch ( c1 )
211             {
212                 case 'i' :
213                     MPUT_GEN(unsigned long, c2);
214                     break;
215                 case 'l' :
216                     MPUT_GEN(unsigned long long, c2);
217                     break;
218                 case 's' :
219                     MPUT_GEN(unsigned short, c2);
220                     break;
221                 case ' ' :
222                     MPUT_GEN(unsigned int, ' ');
223                     break;
224                 case 'c' :
225                     MPUT_CHAR(unsigned char);
226                     break;
227                 default :
228                     *ierr = 1;
229                     return ;
230             }
231             break;
232         default :
233             *ierr = 1;
234             break;
235     }
236 }
237 /*--------------------------------------------------------------------------*/
238 void C2F(mput) (int *fd, double *res, int *n, char *type, int *ierr)
239 {
240     int nc = 0, swap2 = 0;
241     FILE *fa = NULL;
242     *ierr = 0;
243     if ((nc = (int)strlen(type)) == 0)
244     {
245         if ( getWarningMode() )
246         {
247             sciprint(_("%s: Wrong size for input argument #%d ('%s'): Non-empty string expected.\n"), "mput", 4, type);
248         }
249         *ierr = 2;
250         return;
251     }
252
253     if ( *fd == -1  &&  GetFileOpenedInScilab(*fd) == NULL )
254     {
255         sciprint(_("%s: No File opened in Scilab.\n") , "mput" ) ;
256         *ierr = 3 ;
257         return ;
258     }
259
260     if ((fa = GetFileOpenedInScilab(*fd)) != NULL)
261     {
262         swap2 = GetSwapStatus(*fd);
263         mput2(fa, swap2, res, *n, type, ierr);
264         if (*ierr > 0)
265         {
266             if ( getWarningMode() )
267             {
268                 sciprint(_("%s: Wrong value for input argument #%d ('%s'): Format not recognized.\n"), "mput", 4, type);
269             }
270         }
271     }
272     else
273     {
274         if ( getWarningMode() )
275         {
276             sciprint(_("%s: Error while opening, reading or writing '%s'.\n"), "mput", GetFileNameOpenedInScilab(*fd));
277         }
278         *ierr = 3;
279     }
280 }
281 /*--------------------------------------------------------------------------*/
282
283