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