simgear/io/lowlevel.cxx

   1 // lowlevel.cxx -- routines to handle lowlevel compressed binary IO of
   2 //                 various datatypes
   3 //
   4 // Shamelessly adapted from plib (plib.sourceforge.net) January 2001
   5 //
   6 // Original version Copyright (C) 2000  the plib team
   7 // Local changes Copyright (C) 2000  Curtis L. Olson  - curt@flightgear.org
   8 //
   9 // This program is free software; you can redistribute it and/or modify
  10 // it under the terms of the GNU General Public License as published by
  11 // the Free Software Foundation; either version 2 of the License, or
  12 // (at your option) any later version.
  13 //
  14 // This program is distributed in the hope that it will be useful,
  15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 // GNU General Public License for more details.
  18 //
  19 // You should have received a copy of the GNU General Public License
  20 // along with this program; if not, write to the Free Software
  21 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 //
  23 // $Id$
  24
  25
  26 #include "lowlevel.hxx"
  27
  28
  29 static int  read_error = false ;
  30 static int write_error = false ;
  31
  32 void sgClearReadError() { read_error = false; }
  33 void sgClearWriteError() { write_error = false; }
  34 int sgReadError() { return  read_error ; }
  35 int sgWriteError() { return write_error ; }
  36
  37
  38 void sgReadChar ( gzFile fd, char *var )
  39 {
  40     if ( gzread ( fd, var, sizeof(char) ) != sizeof(char) ) {
  41         read_error = true ;
  42     }
  43 }
  44
  45
  46 void sgWriteChar ( gzFile fd, const char var )
  47 {
  48     if ( gzwrite ( fd, (void *)(&var), sizeof(char) ) != sizeof(char) ) {
  49         write_error = true ;
  50     }
  51 }
  52
  53
  54 void sgReadFloat ( gzFile fd, float *var )
  55 {
  56     if ( gzread ( fd, var, sizeof(float) ) != sizeof(float) ) {
  57         read_error = true ;
  58     }
  59     if ( sgIsBigEndian() ) {
  60         sgEndianSwap( (unsigned int*)var);
  61     }
  62 }
  63
  64
  65 void sgWriteFloat ( gzFile fd, const float var )
  66 {
  67     if ( sgIsBigEndian() ) {
  68         sgEndianSwap( (unsigned int*)&var);
  69     }
  70     if ( gzwrite ( fd, (void *)(&var), sizeof(float) ) != sizeof(float) ) {
  71         write_error = true ;
  72     }
  73 }
  74
  75
  76 void sgReadDouble ( gzFile fd, double *var )
  77 {
  78     if ( gzread ( fd, var, sizeof(double) ) != sizeof(double) ) {
  79         read_error = true ;
  80     }
  81     if ( sgIsBigEndian() ) {
  82         sgEndianSwap( (unsigned long long*)var);
  83     }
  84 }
  85
  86
  87 void sgWriteDouble ( gzFile fd, const double var )
  88 {
  89     if ( sgIsBigEndian() ) {
  90         sgEndianSwap( (unsigned long long*)&var);
  91     }
  92     if ( gzwrite ( fd, (void *)(&var), sizeof(double) ) != sizeof(double) ) {
  93         write_error = true ;
  94     }
  95 }
  96
  97
  98 void sgReadUInt ( gzFile fd, unsigned int *var )
  99 {
 100     if ( gzread ( fd, var, sizeof(unsigned int) ) != sizeof(unsigned int) ) {
 101         read_error = true ;
 102     }
 103     if ( sgIsBigEndian() ) {
 104         sgEndianSwap( (unsigned int*)var);
 105     }
 106 }
 107
 108
 109 void sgWriteUInt ( gzFile fd, const unsigned int var )
 110 {
 111     if ( sgIsBigEndian() ) {
 112         sgEndianSwap( (unsigned int*)&var);
 113     }
 114     if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned int) )
 115          != sizeof(unsigned int) )
 116     {
 117         write_error = true ;
 118     }
 119 }
 120
 121
 122 void sgReadInt ( gzFile fd, int *var )
 123 {
 124     if ( gzread ( fd, var, sizeof(int) ) != sizeof(int) ) {
 125         read_error = true ;
 126     }
 127     if ( sgIsBigEndian() ) {
 128         sgEndianSwap( (unsigned int*)var);
 129     }
 130 }
 131
 132
 133 void sgWriteInt ( gzFile fd, const int var )
 134 {
 135     if ( sgIsBigEndian() ) {
 136         sgEndianSwap( (unsigned int*)&var);
 137     }
 138     if ( gzwrite ( fd, (void *)(&var), sizeof(int) ) != sizeof(int) ) {
 139         write_error = true ;
 140     }
 141 }
 142
 143
 144 void sgReadLong ( gzFile fd, long int *var )
 145 {
 146     if ( gzread ( fd, var, sizeof(long int) ) != sizeof(long int) ) {
 147         read_error = true ;
 148     }
 149     if ( sgIsBigEndian() ) {
 150         sgEndianSwap( (unsigned int*)var);
 151     }
 152 }
 153
 154
 155 void sgWriteLong ( gzFile fd, const long int var )
 156 {
 157     if ( sgIsBigEndian() ) {
 158         sgEndianSwap( (unsigned int*)&var);
 159     }
 160     if ( gzwrite ( fd, (void *)(&var), sizeof(long int) )
 161          != sizeof(long int) )
 162     {
 163         write_error = true ;
 164     }
 165 }
 166
 167
 168 void sgReadLongLong ( gzFile fd, long long int *var )
 169 {
 170     if ( gzread ( fd, var, sizeof(long long int) ) != sizeof(long long int) ) {
 171         read_error = true ;
 172     }
 173     if ( sgIsBigEndian() ) {
 174         sgEndianSwap( (unsigned long long int*)var);
 175     }
 176 }
 177
 178
 179 void sgWriteLongLong ( gzFile fd, const long long int var )
 180 {
 181     if ( sgIsBigEndian() ) {
 182         sgEndianSwap( (unsigned long long*)&var);
 183     }
 184     if ( gzwrite ( fd, (void *)(&var), sizeof(long long int) )
 185          != sizeof(long long int) )
 186     {
 187         write_error = true ;
 188     }
 189 }
 190
 191
 192 void sgReadUShort ( gzFile fd, unsigned short *var )
 193 {
 194     if ( gzread ( fd, var, sizeof(unsigned short) ) != sizeof(unsigned short) ){
 195         read_error = true ;
 196     }
 197     if ( sgIsBigEndian() ) {
 198         sgEndianSwap( (unsigned short int*)var);
 199     }
 200 }
 201
 202
 203 void sgWriteUShort ( gzFile fd, const unsigned short var )
 204 {
 205     if ( sgIsBigEndian() ) {
 206         sgEndianSwap( (unsigned short*)&var);
 207     }
 208     if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned short) )
 209          != sizeof(unsigned short) )
 210     {
 211         write_error = true ;
 212     }
 213 }
 214
 215
 216 void sgReadShort ( gzFile fd, short *var )
 217 {
 218     if ( gzread ( fd, var, sizeof(short) ) != sizeof(short) ) {
 219         read_error = true ;
 220     }
 221     if ( sgIsBigEndian() ) {
 222         sgEndianSwap( (unsigned short int*)var);
 223     }
 224 }
 225
 226
 227 void sgWriteShort ( gzFile fd, const short var )
 228 {
 229     if ( sgIsBigEndian() ) {
 230         sgEndianSwap( (unsigned short*)&var);
 231     }
 232     if ( gzwrite ( fd, (void *)(&var), sizeof(short) ) != sizeof(short) ) {
 233         write_error = true ;
 234     }
 235 }
 236
 237
 238 void sgReadFloat ( gzFile fd, const unsigned int n, float *var )
 239 {
 240     if ( gzread ( fd, var, sizeof(float) * n ) != (int)(sizeof(float) * n) ) {
 241         read_error = true ;
 242     }
 243     if ( sgIsBigEndian() ) {
 244         for ( unsigned int i = 0; i < n; ++i ) {
 245             sgEndianSwap( (unsigned int*)var++);
 246         }
 247     }
 248 }
 249
 250
 251 void sgWriteFloat ( gzFile fd, const unsigned int n, const float *var )
 252 {
 253     if ( sgIsBigEndian() ) {
 254         float *swab = new float[n];
 255         float *ptr = swab;
 256         memcpy( swab, var, sizeof(float) * n );
 257         for ( unsigned int i = 0; i < n; ++i ) {
 258             sgEndianSwap( (unsigned int*)ptr++);
 259         }
 260         var = swab;
 261     }
 262     if ( gzwrite ( fd, (void *)var, sizeof(float) * n )
 263          != (int)(sizeof(float) * n) )
 264     {
 265         write_error = true ;
 266     }
 267 }
 268
 269 void sgReadDouble ( gzFile fd, const unsigned int n, double *var )
 270 {
 271     if ( gzread ( fd, var, sizeof(double) * n ) != (int)(sizeof(double) * n) ) {
 272         read_error = true ;
 273     }
 274     if ( sgIsBigEndian() ) {
 275         for ( unsigned int i = 0; i < n; ++i ) {
 276             sgEndianSwap( (unsigned long long*)var++);
 277         }
 278     }
 279 }
 280
 281
 282 void sgWriteDouble ( gzFile fd, const unsigned int n, const double *var )
 283 {
 284     if ( sgIsBigEndian() ) {
 285         double *swab = new double[n];
 286         double *ptr = swab;
 287         memcpy( swab, var, sizeof(double) * n );
 288         for ( unsigned int i = 0; i < n; ++i ) {
 289             sgEndianSwap( (unsigned long long*)ptr++);
 290         }
 291         var = swab;
 292     }
 293     if ( gzwrite ( fd, (void *)var, sizeof(double) * n )
 294          != (int)(sizeof(double) * n) )
 295     {
 296         write_error = true ;
 297     }
 298 }
 299
 300 void sgReadBytes ( gzFile fd, const unsigned int n, void *var )
 301 {
 302     if ( n == 0) return;
 303     if ( gzread ( fd, var, n ) != (int)n ) {
 304         read_error = true ;
 305     }
 306 }
 307
 308 void sgWriteBytes ( gzFile fd, const unsigned int n, const void *var )
 309 {
 310     if ( n == 0) return;
 311     if ( gzwrite ( fd, (void *)var, n ) != (int)n ) {
 312         write_error = true ;
 313     }
 314 }
 315
 316
 317 void sgReadUShort ( gzFile fd, const unsigned int n, unsigned short *var )
 318 {
 319     if ( gzread ( fd, var, sizeof(unsigned short) * n )
 320          != (int)(sizeof(unsigned short) * n) )
 321     {
 322         read_error = true ;
 323     }
 324     if ( sgIsBigEndian() ) {
 325         for ( unsigned int i = 0; i < n; ++i ) {
 326             sgEndianSwap( (unsigned short int*)var++);
 327         }
 328     }
 329 }
 330
 331
 332 void sgWriteUShort ( gzFile fd, const unsigned int n, const unsigned short *var )
 333 {
 334     if ( sgIsBigEndian() ) {
 335         unsigned short *swab = new unsigned short[n];
 336         unsigned short *ptr = swab;
 337         memcpy( swab, var, sizeof(unsigned short) * n );
 338         for ( unsigned int i = 0; i < n; ++i ) {
 339             sgEndianSwap( (unsigned short*)ptr++);
 340         }
 341         var = swab;
 342     }
 343     if ( gzwrite ( fd, (void *)var, sizeof(unsigned short) * n )
 344          != (int)(sizeof(unsigned short) * n) )
 345     {
 346         write_error = true ;
 347     }
 348 }
 349
 350
 351
 352 void sgReadShort ( gzFile fd, const unsigned int n, short *var )
 353 {
 354     if ( gzread ( fd, var, sizeof(short) * n )
 355          != (int)(sizeof(short) * n) )
 356     {
 357         read_error = true ;
 358     }
 359     if ( sgIsBigEndian() ) {
 360         for ( unsigned int i = 0; i < n; ++i ) {
 361             sgEndianSwap( (unsigned short int*)var++);
 362         }
 363     }
 364 }
 365
 366
 367 void sgWriteShort ( gzFile fd, const unsigned int n, const short *var )
 368 {
 369     if ( sgIsBigEndian() ) {
 370         short *swab = new short[n];
 371         short *ptr = swab;
 372         memcpy( swab, var, sizeof(short) * n );
 373         for ( unsigned int i = 0; i < n; ++i ) {
 374             sgEndianSwap( (unsigned short*)ptr++);
 375         }
 376         var = swab;
 377     }
 378     if ( gzwrite ( fd, (void *)var, sizeof(short) * n )
 379          != (int)(sizeof(short) * n) )
 380     {
 381         write_error = true ;
 382     }
 383 }
 384
 385
 386 void sgReadUInt ( gzFile fd, const unsigned int n, unsigned int *var )
 387 {
 388     if ( gzread ( fd, var, sizeof(unsigned int) * n )
 389          != (int)(sizeof(unsigned int) * n) )
 390     {
 391         read_error = true ;
 392     }
 393     if ( sgIsBigEndian() ) {
 394         for ( unsigned int i = 0; i < n; ++i ) {
 395             sgEndianSwap( (unsigned int*)var++);
 396         }
 397     }
 398 }
 399
 400
 401 void sgWriteUInt ( gzFile fd, const unsigned int n, const unsigned int *var )
 402 {
 403     if ( sgIsBigEndian() ) {
 404         unsigned int *swab = new unsigned int[n];
 405         unsigned int *ptr = swab;
 406         memcpy( swab, var, sizeof(unsigned int) * n );
 407         for ( unsigned int i = 0; i < n; ++i ) {
 408             sgEndianSwap( (unsigned int*)ptr++);
 409         }
 410         var = swab;
 411     }
 412     if ( gzwrite ( fd, (void *)var, sizeof(unsigned int) * n )
 413          != (int)(sizeof(unsigned int) * n) )
 414     {
 415         write_error = true ;
 416     }
 417 }
 418
 419
 420
 421 void sgReadInt ( gzFile fd, const unsigned int n, int *var )
 422 {
 423     if ( gzread ( fd, var, sizeof(int) * n )
 424          != (int)(sizeof(int) * n) )
 425     {
 426         read_error = true ;
 427     }
 428     if ( sgIsBigEndian() ) {
 429         for ( unsigned int i = 0; i < n; ++i ) {
 430             sgEndianSwap( (unsigned int*)var++);
 431         }
 432     }
 433 }
 434
 435
 436 void sgWriteInt ( gzFile fd, const unsigned int n, const int *var )
 437 {
 438     if ( sgIsBigEndian() ) {
 439         int *swab = new int[n];
 440         int *ptr = swab;
 441         memcpy( swab, var, sizeof(int) * n );
 442         for ( unsigned int i = 0; i < n; ++i ) {
 443             sgEndianSwap( (unsigned int*)ptr++);
 444         }
 445         var = swab;
 446     }
 447     if ( gzwrite ( fd, (void *)var, sizeof(int) * n )
 448          != (int)(sizeof(int) * n) )
 449     {
 450         write_error = true ;
 451     }
 452 }
 453
 454
 455
 456 #define MAX_ENTITY_NAME_LENGTH 1024
 457
 458 void sgReadString ( gzFile fd, char **var )
 459 {
 460     int i ;
 461     char s [ MAX_ENTITY_NAME_LENGTH ] ;
 462
 463     for ( i = 0 ; i < MAX_ENTITY_NAME_LENGTH ; i++ ) {
 464         int c = gzgetc ( fd ) ;
 465         s [ i ] = c ;
 466
 467         if ( c == '\0' )
 468             break ;
 469     }
 470
 471     if ( i >= MAX_ENTITY_NAME_LENGTH-1 )
 472         s [ MAX_ENTITY_NAME_LENGTH-1 ] = '\0' ;
 473
 474
 475     if ( s[0] == '\0' )
 476         *var = NULL ;
 477     else {
 478         *var = new char [ strlen(s)+1 ] ;
 479         strcpy ( *var, s ) ;
 480     }
 481 }
 482
 483
 484 void sgWriteString ( gzFile fd, const char *var )
 485 {
 486     if ( var != NULL ) {
 487         if ( gzwrite ( fd, (void *)var, strlen(var) + 1 ) ==
 488              (int)(strlen(var) + 1) )
 489             return ;
 490     } else {
 491         gzputc( fd, 0 );
 492     }
 493 }
 494
 495