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