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 <string.h>             // for memcpy()
  27
  28 #include "lowlevel.hxx"
  29
  30
  31 static int  read_error = false ;
  32 static int write_error = false ;
  33
  34 void sgClearReadError() { read_error = false; }
  35 void sgClearWriteError() { write_error = false; }
  36 int sgReadError() { return  read_error ; }
  37 int sgWriteError() { return write_error ; }
  38
  39
  40 void sgReadChar ( gzFile fd, char *var )
  41 {
  42     if ( gzread ( fd, var, sizeof(char) ) != sizeof(char) ) {
  43         read_error = true ;
  44     }
  45 }
  46
  47
  48 void sgWriteChar ( gzFile fd, const char var )
  49 {
  50     if ( gzwrite ( fd, (void *)(&var), sizeof(char) ) != sizeof(char) ) {
  51         write_error = true ;
  52     }
  53 }
  54
  55
  56 void sgReadFloat ( gzFile fd, float *var )
  57 {
  58     if ( gzread ( fd, var, sizeof(float) ) != sizeof(float) ) {
  59         read_error = true ;
  60     }
  61     if ( sgIsBigEndian() ) {
  62         sgEndianSwap( (unsigned int*)var);
  63     }
  64 }
  65
  66
  67 void sgWriteFloat ( gzFile fd, const float var )
  68 {
  69     if ( sgIsBigEndian() ) {
  70         sgEndianSwap( (unsigned int*)&var);
  71     }
  72     if ( gzwrite ( fd, (void *)(&var), sizeof(float) ) != sizeof(float) ) {
  73         write_error = true ;
  74     }
  75 }
  76
  77
  78 void sgReadDouble ( gzFile fd, double *var )
  79 {
  80     if ( gzread ( fd, var, sizeof(double) ) != sizeof(double) ) {
  81         read_error = true ;
  82     }
  83     if ( sgIsBigEndian() ) {
  84         sgEndianSwap( (uint64*)var);
  85     }
  86 }
  87
  88
  89 void sgWriteDouble ( gzFile fd, const double var )
  90 {
  91     if ( sgIsBigEndian() ) {
  92         sgEndianSwap( (uint64*)&var);
  93     }
  94     if ( gzwrite ( fd, (void *)(&var), sizeof(double) ) != sizeof(double) ) {
  95         write_error = true ;
  96     }
  97 }
  98
  99
 100 void sgReadUInt ( gzFile fd, unsigned int *var )
 101 {
 102     if ( gzread ( fd, var, sizeof(unsigned int) ) != sizeof(unsigned int) ) {
 103         read_error = true ;
 104     }
 105     if ( sgIsBigEndian() ) {
 106         sgEndianSwap( (unsigned int*)var);
 107     }
 108 }
 109
 110
 111 void sgWriteUInt ( gzFile fd, const unsigned int var )
 112 {
 113     if ( sgIsBigEndian() ) {
 114         sgEndianSwap( (unsigned int*)&var);
 115     }
 116     if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned int) )
 117          != sizeof(unsigned int) )
 118     {
 119         write_error = true ;
 120     }
 121 }
 122
 123
 124 void sgReadInt ( gzFile fd, int *var )
 125 {
 126     if ( gzread ( fd, var, sizeof(int) ) != sizeof(int) ) {
 127         read_error = true ;
 128     }
 129     if ( sgIsBigEndian() ) {
 130         sgEndianSwap( (unsigned int*)var);
 131     }
 132 }
 133
 134
 135 void sgWriteInt ( gzFile fd, const int var )
 136 {
 137     if ( sgIsBigEndian() ) {
 138         sgEndianSwap( (unsigned int*)&var);
 139     }
 140     if ( gzwrite ( fd, (void *)(&var), sizeof(int) ) != sizeof(int) ) {
 141         write_error = true ;
 142     }
 143 }
 144
 145
 146 void sgReadLong ( gzFile fd, long int *var )
 147 {
 148     if ( gzread ( fd, var, sizeof(long int) ) != sizeof(long int) ) {
 149         read_error = true ;
 150     }
 151     if ( sgIsBigEndian() ) {
 152         sgEndianSwap( (unsigned int*)var);
 153     }
 154 }
 155
 156
 157 void sgWriteLong ( gzFile fd, const long int var )
 158 {
 159     if ( sgIsBigEndian() ) {
 160         sgEndianSwap( (unsigned int*)&var);
 161     }
 162     if ( gzwrite ( fd, (void *)(&var), sizeof(long int) )
 163          != sizeof(long int) )
 164     {
 165         write_error = true ;
 166     }
 167 }
 168
 169
 170 void sgReadLongLong ( gzFile fd, int64 *var )
 171 {
 172     if ( gzread ( fd, var, sizeof(int64) ) != sizeof(int64) ) {
 173         read_error = true ;
 174     }
 175     if ( sgIsBigEndian() ) {
 176         sgEndianSwap( (uint64*)var);
 177     }
 178 }
 179
 180
 181 void sgWriteLongLong ( gzFile fd, const int64 var )
 182 {
 183     if ( sgIsBigEndian() ) {
 184         sgEndianSwap( (uint64*)&var);
 185     }
 186     if ( gzwrite ( fd, (void *)(&var), sizeof(int64) )
 187          != sizeof(int64) )
 188     {
 189         write_error = true ;
 190     }
 191 }
 192
 193
 194 void sgReadUShort ( gzFile fd, unsigned short *var )
 195 {
 196     if ( gzread ( fd, var, sizeof(unsigned short) ) != sizeof(unsigned short) ){
 197         read_error = true ;
 198     }
 199     if ( sgIsBigEndian() ) {
 200         sgEndianSwap( (unsigned short int*)var);
 201     }
 202 }
 203
 204
 205 void sgWriteUShort ( gzFile fd, const unsigned short var )
 206 {
 207     if ( sgIsBigEndian() ) {
 208         sgEndianSwap( (unsigned short*)&var);
 209     }
 210     if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned short) )
 211          != sizeof(unsigned short) )
 212     {
 213         write_error = true ;
 214     }
 215 }
 216
 217
 218 void sgReadShort ( gzFile fd, short *var )
 219 {
 220     if ( gzread ( fd, var, sizeof(short) ) != sizeof(short) ) {
 221         read_error = true ;
 222     }
 223     if ( sgIsBigEndian() ) {
 224         sgEndianSwap( (unsigned short int*)var);
 225     }
 226 }
 227
 228
 229 void sgWriteShort ( gzFile fd, const short var )
 230 {
 231     if ( sgIsBigEndian() ) {
 232         sgEndianSwap( (unsigned short*)&var);
 233     }
 234     if ( gzwrite ( fd, (void *)(&var), sizeof(short) ) != sizeof(short) ) {
 235         write_error = true ;
 236     }
 237 }
 238
 239
 240 void sgReadFloat ( gzFile fd, const unsigned int n, float *var )
 241 {
 242     if ( gzread ( fd, var, sizeof(float) * n ) != (int)(sizeof(float) * n) ) {
 243         read_error = true ;
 244     }
 245     if ( sgIsBigEndian() ) {
 246         for ( unsigned int i = 0; i < n; ++i ) {
 247             sgEndianSwap( (unsigned int*)var++);
 248         }
 249     }
 250 }
 251
 252
 253 void sgWriteFloat ( gzFile fd, const unsigned int n, const float *var )
 254 {
 255     if ( sgIsBigEndian() ) {
 256         float *swab = new float[n];
 257         float *ptr = swab;
 258         memcpy( swab, var, sizeof(float) * n );
 259         for ( unsigned int i = 0; i < n; ++i ) {
 260             sgEndianSwap( (unsigned int*)ptr++);
 261         }
 262         var = swab;
 263     }
 264     if ( gzwrite ( fd, (void *)var, sizeof(float) * n )
 265          != (int)(sizeof(float) * n) )
 266     {
 267         write_error = true ;
 268     }
 269 }
 270
 271 void sgReadDouble ( gzFile fd, const unsigned int n, double *var )
 272 {
 273     if ( gzread ( fd, var, sizeof(double) * n ) != (int)(sizeof(double) * n) ) {
 274         read_error = true ;
 275     }
 276     if ( sgIsBigEndian() ) {
 277         for ( unsigned int i = 0; i < n; ++i ) {
 278             sgEndianSwap( (uint64*)var++);
 279         }
 280     }
 281 }
 282
 283
 284 void sgWriteDouble ( gzFile fd, const unsigned int n, const double *var )
 285 {
 286     if ( sgIsBigEndian() ) {
 287         double *swab = new double[n];
 288         double *ptr = swab;
 289         memcpy( swab, var, sizeof(double) * n );
 290         for ( unsigned int i = 0; i < n; ++i ) {
 291             sgEndianSwap( (uint64*)ptr++);
 292         }
 293         var = swab;
 294     }
 295     if ( gzwrite ( fd, (void *)var, sizeof(double) * n )
 296          != (int)(sizeof(double) * n) )
 297     {
 298         write_error = true ;
 299     }
 300 }
 301
 302 void sgReadBytes ( gzFile fd, const unsigned int n, void *var )
 303 {
 304     if ( n == 0) return;
 305     if ( gzread ( fd, var, n ) != (int)n ) {
 306         read_error = true ;
 307     }
 308 }
 309
 310 void sgWriteBytes ( gzFile fd, const unsigned int n, const void *var )
 311 {
 312     if ( n == 0) return;
 313     if ( gzwrite ( fd, (void *)var, n ) != (int)n ) {
 314         write_error = true ;
 315     }
 316 }
 317
 318
 319 void sgReadUShort ( gzFile fd, const unsigned int n, unsigned short *var )
 320 {
 321     if ( gzread ( fd, var, sizeof(unsigned short) * n )
 322          != (int)(sizeof(unsigned short) * n) )
 323     {
 324         read_error = true ;
 325     }
 326     if ( sgIsBigEndian() ) {
 327         for ( unsigned int i = 0; i < n; ++i ) {
 328             sgEndianSwap( (unsigned short int*)var++);
 329         }
 330     }
 331 }
 332
 333
 334 void sgWriteUShort ( gzFile fd, const unsigned int n, const unsigned short *var )
 335 {
 336     if ( sgIsBigEndian() ) {
 337         unsigned short *swab = new unsigned short[n];
 338         unsigned short *ptr = swab;
 339         memcpy( swab, var, sizeof(unsigned short) * n );
 340         for ( unsigned int i = 0; i < n; ++i ) {
 341             sgEndianSwap( (unsigned short*)ptr++);
 342         }
 343         var = swab;
 344     }
 345     if ( gzwrite ( fd, (void *)var, sizeof(unsigned short) * n )
 346          != (int)(sizeof(unsigned short) * n) )
 347     {
 348         write_error = true ;
 349     }
 350 }
 351
 352
 353
 354 void sgReadShort ( gzFile fd, const unsigned int n, short *var )
 355 {
 356     if ( gzread ( fd, var, sizeof(short) * n )
 357          != (int)(sizeof(short) * n) )
 358     {
 359         read_error = true ;
 360     }
 361     if ( sgIsBigEndian() ) {
 362         for ( unsigned int i = 0; i < n; ++i ) {
 363             sgEndianSwap( (unsigned short int*)var++);
 364         }
 365     }
 366 }
 367
 368
 369 void sgWriteShort ( gzFile fd, const unsigned int n, const short *var )
 370 {
 371     if ( sgIsBigEndian() ) {
 372         short *swab = new short[n];
 373         short *ptr = swab;
 374         memcpy( swab, var, sizeof(short) * n );
 375         for ( unsigned int i = 0; i < n; ++i ) {
 376             sgEndianSwap( (unsigned short*)ptr++);
 377         }
 378         var = swab;
 379     }
 380     if ( gzwrite ( fd, (void *)var, sizeof(short) * n )
 381          != (int)(sizeof(short) * n) )
 382     {
 383         write_error = true ;
 384     }
 385 }
 386
 387
 388 void sgReadUInt ( gzFile fd, const unsigned int n, unsigned int *var )
 389 {
 390     if ( gzread ( fd, var, sizeof(unsigned int) * n )
 391          != (int)(sizeof(unsigned int) * n) )
 392     {
 393         read_error = true ;
 394     }
 395     if ( sgIsBigEndian() ) {
 396         for ( unsigned int i = 0; i < n; ++i ) {
 397             sgEndianSwap( (unsigned int*)var++);
 398         }
 399     }
 400 }
 401
 402
 403 void sgWriteUInt ( gzFile fd, const unsigned int n, const unsigned int *var )
 404 {
 405     if ( sgIsBigEndian() ) {
 406         unsigned int *swab = new unsigned int[n];
 407         unsigned int *ptr = swab;
 408         memcpy( swab, var, sizeof(unsigned int) * n );
 409         for ( unsigned int i = 0; i < n; ++i ) {
 410             sgEndianSwap( (unsigned int*)ptr++);
 411         }
 412         var = swab;
 413     }
 414     if ( gzwrite ( fd, (void *)var, sizeof(unsigned int) * n )
 415          != (int)(sizeof(unsigned int) * n) )
 416     {
 417         write_error = true ;
 418     }
 419 }
 420
 421
 422
 423 void sgReadInt ( gzFile fd, const unsigned int n, int *var )
 424 {
 425     if ( gzread ( fd, var, sizeof(int) * n )
 426          != (int)(sizeof(int) * n) )
 427     {
 428         read_error = true ;
 429     }
 430     if ( sgIsBigEndian() ) {
 431         for ( unsigned int i = 0; i < n; ++i ) {
 432             sgEndianSwap( (unsigned int*)var++);
 433         }
 434     }
 435 }
 436
 437
 438 void sgWriteInt ( gzFile fd, const unsigned int n, const int *var )
 439 {
 440     if ( sgIsBigEndian() ) {
 441         int *swab = new int[n];
 442         int *ptr = swab;
 443         memcpy( swab, var, sizeof(int) * n );
 444         for ( unsigned int i = 0; i < n; ++i ) {
 445             sgEndianSwap( (unsigned int*)ptr++);
 446         }
 447         var = swab;
 448     }
 449     if ( gzwrite ( fd, (void *)var, sizeof(int) * n )
 450          != (int)(sizeof(int) * n) )
 451     {
 452         write_error = true ;
 453     }
 454 }
 455
 456
 457
 458 #define MAX_ENTITY_NAME_LENGTH 1024
 459
 460 void sgReadString ( gzFile fd, char **var )
 461 {
 462     int i ;
 463     char s [ MAX_ENTITY_NAME_LENGTH ] ;
 464
 465     for ( i = 0 ; i < MAX_ENTITY_NAME_LENGTH ; i++ ) {
 466         int c = gzgetc ( fd ) ;
 467         s [ i ] = c ;
 468
 469         if ( c == '\0' )
 470             break ;
 471     }
 472
 473     if ( i >= MAX_ENTITY_NAME_LENGTH-1 )
 474         s [ MAX_ENTITY_NAME_LENGTH-1 ] = '\0' ;
 475
 476
 477     if ( s[0] == '\0' )
 478         *var = NULL ;
 479     else {
 480         *var = new char [ strlen(s)+1 ] ;
 481         strcpy ( *var, s ) ;
 482     }
 483 }
 484
 485
 486 void sgWriteString ( gzFile fd, const char *var )
 487 {
 488     if ( var != NULL ) {
 489         if ( gzwrite ( fd, (void *)var, strlen(var) + 1 ) ==
 490              (int)(strlen(var) + 1) )
 491             return ;
 492     } else {
 493         gzputc( fd, 0 );
 494     }
 495 }
 496
 497