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, 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, 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, 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 /*--------------------------------------------------------------------------*/