simgear/io/lowlevel.cxx

   1 // lowlevel.hxx -- 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 static int  read_error = false ;
  29 static int write_error = false ;
  30
  31 void sgClearReadError() { read_error = false; }
  32 void sgClearWriteError() { write_error = false; }
  33 int sgReadError() { return  read_error ; }
  34 int sgWriteError() { return write_error ; }
  35
  36
  37 void sgReadChar ( gzFile fd, char *var )
  38 {
  39     if ( gzread ( fd, var, sizeof(char) ) == sizeof(char) ) return ;
  40     read_error = true ;
  41 }
  42
  43
  44 void sgWriteChar ( gzFile fd, const char var )
  45 {
  46     if ( gzwrite ( fd, (void *)(&var), sizeof(char) ) == sizeof(char) ) return ;
  47     write_error = true ;
  48 }
  49
  50
  51 void sgReadFloat ( gzFile fd, float *var )
  52 {
  53     if ( gzread ( fd, var, sizeof(float) ) == sizeof(float) ) return ;
  54     read_error = true ;
  55 }
  56
  57
  58 void sgWriteFloat ( gzFile fd, const float var )
  59 {
  60     if ( gzwrite ( fd, (void *)(&var), sizeof(float) ) == sizeof(float) )
  61         return ;
  62     write_error = true ;
  63 }
  64
  65
  66 void sgReadDouble ( gzFile fd, double *var )
  67 {
  68     if ( gzread ( fd, var, sizeof(double) ) == sizeof(double) ) return ;
  69     read_error = true ;
  70 }
  71
  72
  73 void sgWriteDouble ( gzFile fd, const double var )
  74 {
  75     if ( gzwrite ( fd, (void *)(&var), sizeof(double) ) == sizeof(double) )
  76         return ;
  77     write_error = true ;
  78 }
  79
  80
  81 void sgReadUInt ( gzFile fd, unsigned int *var )
  82 {
  83     if ( gzread ( fd, var, sizeof(unsigned int) ) == sizeof(unsigned int) )
  84         return ;
  85     read_error = true ;
  86 }
  87
  88
  89 void sgWriteUInt ( gzFile fd, const unsigned int var )
  90 {
  91     if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned int) )
  92          == sizeof(unsigned int) )
  93         return ;
  94     write_error = true ;
  95 }
  96
  97
  98 void sgReadInt ( gzFile fd, int *var )
  99 {
 100     if ( gzread ( fd, var, sizeof(int) ) == sizeof(int) ) return ;
 101     read_error = true ;
 102 }
 103
 104
 105 void sgWriteInt ( gzFile fd, const int var )
 106 {
 107     if ( gzwrite ( fd, (void *)(&var), sizeof(int) ) == sizeof(int) ) return ;
 108     write_error = true ;
 109 }
 110
 111
 112 void sgReadLong ( gzFile fd, long int *var )
 113 {
 114     if ( gzread ( fd, var, sizeof(long int) ) == sizeof(long int) ) return ;
 115     read_error = true ;
 116 }
 117
 118
 119 void sgWriteLong ( gzFile fd, const long int var )
 120 {
 121     if ( gzwrite ( fd, (void *)(&var), sizeof(long int) ) == sizeof(long int) )
 122         return ;
 123     write_error = true ;
 124 }
 125
 126
 127 void sgReadUShort ( gzFile fd, unsigned short *var )
 128 {
 129     if ( gzread ( fd, var, sizeof(unsigned short) ) == sizeof(unsigned short) )
 130         return ;
 131     read_error = true ;
 132 }
 133
 134
 135 void sgWriteUShort ( gzFile fd, const unsigned short var )
 136 {
 137     if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned short) )
 138          == sizeof(unsigned short) )
 139         return ;
 140     write_error = true ;
 141 }
 142
 143
 144 void sgReadShort ( gzFile fd, short *var )
 145 {
 146     if ( gzread ( fd, var, sizeof(short) ) == sizeof(short) ) return ;
 147     read_error = true ;
 148 }
 149
 150
 151 void sgWriteShort ( gzFile fd, const short var )
 152 {
 153     if ( gzwrite ( fd, (void *)(&var), sizeof(short) ) == sizeof(short) ) return ;
 154     write_error = true ;
 155 }
 156
 157
 158 void sgReadFloat ( gzFile fd, const unsigned int n, float *var )
 159 {
 160     if ( gzread ( fd, var, sizeof(float) * n ) == (int)(sizeof(float) * n) )
 161         return ;
 162     read_error = true ;
 163 }
 164
 165
 166 void sgWriteFloat ( gzFile fd, const unsigned int n, const float *var )
 167 {
 168     if ( gzwrite ( fd, (void *)var, sizeof(float) * n )
 169          == (int)(sizeof(float) * n) )
 170         return ;
 171     write_error = true ;
 172 }
 173
 174 void sgReadDouble ( gzFile fd, const unsigned int n, double *var )
 175 {
 176     if ( gzread ( fd, var, sizeof(double) * n ) == (int)(sizeof(double) * n) )
 177         return ;
 178     read_error = true ;
 179 }
 180
 181
 182 void sgWriteDouble ( gzFile fd, const unsigned int n, const double *var )
 183 {
 184     if ( gzwrite ( fd, (void *)var, sizeof(double) * n )
 185          == (int)(sizeof(double) * n) ) return ;
 186     write_error = true ;
 187 }
 188
 189 void sgReadBytes ( gzFile fd, const unsigned int n, void *var )
 190 {
 191     if ( n == 0)
 192         return;
 193     if ( gzread ( fd, var, n ) == (int)n )
 194         return ;
 195     read_error = true ;
 196 }
 197
 198 void sgWriteBytes ( gzFile fd, const unsigned int n, const void *var )
 199 {
 200     if ( n == 0)
 201         return;
 202     if ( gzwrite ( fd, (void *)var, n ) == (int)n )
 203         return ;
 204     write_error = true ;
 205 }
 206
 207
 208 void sgReadUShort ( gzFile fd, const unsigned int n, unsigned short *var )
 209 {
 210     if ( gzread ( fd, var, sizeof(unsigned short) * n )
 211          == (int)(sizeof(unsigned short) * n) )
 212         return ;
 213     read_error = true ;
 214 }
 215
 216
 217 void sgWriteUShort ( gzFile fd, const unsigned int n, const unsigned short *var )
 218 {
 219     if ( gzwrite ( fd, (void *)var, sizeof(unsigned short) * n )
 220          == (int)(sizeof(unsigned short) * n) )
 221         return ;
 222     write_error = true ;
 223 }
 224
 225
 226
 227 void sgReadShort ( gzFile fd, const unsigned int n, short *var )
 228 {
 229     if ( gzread ( fd, var, sizeof(short) * n )
 230          == (int)(sizeof(short) * n) )
 231         return ;
 232     read_error = true ;
 233 }
 234
 235
 236 void sgWriteShort ( gzFile fd, const unsigned int n, const short *var )
 237 {
 238     if ( gzwrite ( fd, (void *)var, sizeof(short) * n )
 239          == (int)(sizeof(short) * n) )
 240         return ;
 241     write_error = true ;
 242 }
 243
 244
 245 void sgReadUInt ( gzFile fd, const unsigned int n, unsigned int *var )
 246 {
 247     if ( gzread ( fd, var, sizeof(unsigned int) * n )
 248          == (int)(sizeof(unsigned int) * n) )
 249         return ;
 250     read_error = true ;
 251 }
 252
 253
 254 void sgWriteUInt ( gzFile fd, const unsigned int n, const unsigned int *var )
 255 {
 256     if ( gzwrite ( fd, (void *)var, sizeof(unsigned int) * n )
 257          == (int)(sizeof(unsigned int) * n) )
 258         return ;
 259     write_error = true ;
 260 }
 261
 262
 263
 264 void sgReadInt ( gzFile fd, const unsigned int n, int *var )
 265 {
 266     if ( gzread ( fd, var, sizeof(int) * n )
 267          == (int)(sizeof(int) * n) )
 268         return ;
 269     read_error = true ;
 270 }
 271
 272
 273 void sgWriteInt ( gzFile fd, const unsigned int n, const int *var )
 274 {
 275     if ( gzwrite ( fd, (void *)var, sizeof(int) * n )
 276          == (int)(sizeof(int) * n) )
 277         return ;
 278     write_error = true ;
 279 }
 280
 281
 282
 283 #define MAX_ENTITY_NAME_LENGTH 1024
 284
 285 void sgReadString ( gzFile fd, char **var )
 286 {
 287     int i ;
 288     char s [ MAX_ENTITY_NAME_LENGTH ] ;
 289
 290     for ( i = 0 ; i < MAX_ENTITY_NAME_LENGTH ; i++ ) {
 291         int c = gzgetc ( fd ) ;
 292         s [ i ] = c ;
 293
 294         if ( c == '\0' )
 295             break ;
 296     }
 297
 298     if ( i >= MAX_ENTITY_NAME_LENGTH-1 )
 299         s [ MAX_ENTITY_NAME_LENGTH-1 ] = '\0' ;
 300
 301
 302     if ( s[0] == '\0' )
 303         *var = NULL ;
 304     else {
 305         *var = new char [ strlen(s)+1 ] ;
 306         strcpy ( *var, s ) ;
 307     }
 308 }
 309
 310
 311 void sgWriteString ( gzFile fd, const char *var )
 312 {
 313     if ( var != NULL ) {
 314         if ( gzwrite ( fd, (void *)var, strlen(var) + 1 ) ==
 315              (int)(strlen(var) + 1) )
 316             return ;
 317     } else {
 318         gzputc( fd, 0 );
 319     }
 320 }
 321
 322
 323 void sgReadVec2  ( gzFile fd, sgVec2 var ) { sgReadFloat  ( fd, 2, var ) ; }
 324 void sgWriteVec2 ( gzFile fd, const sgVec2 var ) {
 325     sgWriteFloat ( fd, 2, var ) ;
 326 }
 327
 328 void sgReadVec3  ( gzFile fd, sgVec3 var ) { sgReadFloat  ( fd, 3, var ) ; }
 329 void sgWriteVec3 ( gzFile fd, const sgVec3 var ) {
 330     sgWriteFloat ( fd, 3, var ) ;
 331 }
 332
 333 void sgReaddVec3  ( gzFile fd, sgdVec3 var ) { sgReadDouble  ( fd, 3, var ) ; }
 334 void sgWritedVec3 ( gzFile fd, const sgdVec3 var ) {
 335     sgWriteDouble ( fd, 3, var ) ;
 336 }
 337
 338 void sgReadVec4  ( gzFile fd, sgVec4 var ) { sgReadFloat  ( fd, 4, var ) ; }
 339 void sgWriteVec4 ( gzFile fd, const sgVec4 var ) {
 340     sgWriteFloat ( fd, 4, var ) ;
 341 }
 342
 343 void sgReadMat4  ( gzFile fd, sgMat4 var ) {
 344     sgReadFloat  ( fd, 16, (float *)var ) ;
 345 }
 346 void sgWriteMat4 ( gzFile fd, const sgMat4 var ) {
 347     sgWriteFloat ( fd, 16, (float *)var ) ;
 348 }