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