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