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