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