Fix for HTTP/curl waiting on update

[simgear.git] / simgear / io / lowlevel.cxx

diff --git a/simgear/io/lowlevel.cxx b/simgear/io/lowlevel.cxx
index 54ba40c365cb2b2371844801c2c6113e29f1ed89..d41bc801a03f2669f9442d3eb2446f3d237bc13f 100644 (file)
--- a/simgear/io/lowlevel.cxx
+++ b/simgear/io/lowlevel.cxx
@@ -1,10 +1,10 @@
-// lowlevel.hxx -- routines to handle lowlevel compressed binary IO of
+// lowlevel.cxx -- routines to handle lowlevel compressed binary IO of
 //                 various datatypes
 //
 // Shamelessly adapted from plib (plib.sourceforge.net) January 2001
 //
 // Original version Copyright (C) 2000  the plib team
-// Local changes Copyright (C) 2000  Curtis L. Olson  - curt@flightgear.org
+// Local changes Copyright (C) 2000  Curtis L. Olson  - http://www.flightgear.org/~curt
 //
 // This program is free software; you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -18,13 +18,20 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program; if not, write to the Free Software
-// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 // $Id$
-//
+
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <string.h>            // for memcpy()
 
 #include "lowlevel.hxx" 
 
+
 static int  read_error = false ;
 static int write_error = false ;
 
@@ -33,36 +40,7 @@ void sgClearWriteError() { write_error = false; }
 int sgReadError() { return  read_error ; }
 int sgWriteError() { return write_error ; }
 
-static const int sgEndianTest = 1;
-#define sgIsLittleEndian (*((char *) &sgEndianTest ) != 0)
-#define sgIsBigEndian    (*((char *) &sgEndianTest ) == 0)
-
-static inline void sgEndianSwap(unsigned short *x) {
-    *x =
-        (( *x >>  8 ) & 0x00FF ) | 
-        (( *x <<  8 ) & 0xFF00 ) ;
-}
-  
-static inline void sgEndianSwap(unsigned int *x) {
-    *x =
-        (( *x >> 24 ) & 0x000000FF ) | 
-        (( *x >>  8 ) & 0x0000FF00 ) | 
-        (( *x <<  8 ) & 0x00FF0000 ) | 
-        (( *x << 24 ) & 0xFF000000 ) ;
-}
-  
-static inline void sgEndianSwap(unsigned long long *x) {
-    *x =
-        (( *x >> 56 ) & 0x00000000000000FFULL ) | 
-        (( *x >> 40 ) & 0x000000000000FF00ULL ) | 
-        (( *x >> 24 ) & 0x0000000000FF0000ULL ) | 
-        (( *x >>  8 ) & 0x00000000FF000000ULL ) | 
-        (( *x <<  8 ) & 0x000000FF00000000ULL ) | 
-        (( *x << 24 ) & 0x0000FF0000000000ULL ) |
-        (( *x << 40 ) & 0x00FF000000000000ULL ) |
-        (( *x << 56 ) & 0xFF00000000000000ULL ) ;
-}
-  
+
 void sgReadChar ( gzFile fd, char *var )
 {
     if ( gzread ( fd, var, sizeof(char) ) != sizeof(char) ) {
@@ -81,21 +59,25 @@ void sgWriteChar ( gzFile fd, const char var )
 
 void sgReadFloat ( gzFile fd, float *var )
 {
-    if ( gzread ( fd, var, sizeof(float) ) != sizeof(float) ) {
+    union { float v; uint32_t u; } buf;
+    if ( gzread ( fd, &buf.u, sizeof(float) ) != sizeof(float) ) {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned int*)var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( &buf.u );
     }
+    *var = buf.v;
 }
 
 
 void sgWriteFloat ( gzFile fd, const float var )
 {
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned int*)&var);
+    union { float v; uint32_t u; } buf;
+    buf.v = var;
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( &buf.u );
     }
-    if ( gzwrite ( fd, (void *)(&var), sizeof(float) ) != sizeof(float) ) {
+    if ( gzwrite ( fd, (void *)(&buf.u), sizeof(float) ) != sizeof(float) ) {
         write_error = true ;
     }
 }
@@ -103,21 +85,25 @@ void sgWriteFloat ( gzFile fd, const float var )
 
 void sgReadDouble ( gzFile fd, double *var )
 {
-    if ( gzread ( fd, var, sizeof(double) ) != sizeof(double) ) {
+    union { double v; uint64_t u; } buf;
+    if ( gzread ( fd, &buf.u, sizeof(double) ) != sizeof(double) ) {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned long long*)var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( &buf.u );
     }
+    *var = buf.v;
 }
 
 
 void sgWriteDouble ( gzFile fd, const double var )
 {
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned long long*)&var);
+    union { double v; uint64_t u; } buf;
+    buf.v = var;
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( &buf.u );
     }
-    if ( gzwrite ( fd, (void *)(&var), sizeof(double) ) != sizeof(double) ) {
+    if ( gzwrite ( fd, (void *)(&buf.u), sizeof(double) ) != sizeof(double) ) {
         write_error = true ;
     }
 }
@@ -128,16 +114,16 @@ void sgReadUInt ( gzFile fd, unsigned int *var )
     if ( gzread ( fd, var, sizeof(unsigned int) ) != sizeof(unsigned int) ) {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned int*)var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint32_t *)var);
     }
 }
 
 
 void sgWriteUInt ( gzFile fd, const unsigned int var )
 {
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned int*)&var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint32_t *)&var);
     }
     if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned int) )
         != sizeof(unsigned int) )
@@ -152,16 +138,16 @@ void sgReadInt ( gzFile fd, int *var )
     if ( gzread ( fd, var, sizeof(int) ) != sizeof(int) ) {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned int*)var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint32_t *)var);
     }
 }
 
 
 void sgWriteInt ( gzFile fd, const int var )
 {
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned int*)&var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint32_t *)&var);
     }
     if ( gzwrite ( fd, (void *)(&var), sizeof(int) ) != sizeof(int) ) {
         write_error = true ;
@@ -169,48 +155,48 @@ void sgWriteInt ( gzFile fd, const int var )
 }
 
 
-void sgReadLong ( gzFile fd, long int *var )
+void sgReadLong ( gzFile fd, int32_t *var )
 {
-    if ( gzread ( fd, var, sizeof(long int) ) != sizeof(long int) ) {
+    if ( gzread ( fd, var, sizeof(int32_t) ) != sizeof(int32_t) ) {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned int*)var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint32_t *)var);
     }
 }
 
 
-void sgWriteLong ( gzFile fd, const long int var )
+void sgWriteLong ( gzFile fd, const int32_t var )
 {
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned int*)&var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint32_t *)&var);
     }
-    if ( gzwrite ( fd, (void *)(&var), sizeof(long int) )
-         != sizeof(long int) )
+    if ( gzwrite ( fd, (void *)(&var), sizeof(int32_t) )
+         != sizeof(int32_t) )
     {
         write_error = true ;
     }
 }
 
 
-void sgReadLongLong ( gzFile fd, long long int *var )
+void sgReadLongLong ( gzFile fd, int64_t *var )
 {
-    if ( gzread ( fd, var, sizeof(long long int) ) != sizeof(long long int) ) {
+    if ( gzread ( fd, var, sizeof(int64_t) ) != sizeof(int64_t) ) {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned long long int*)var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint64_t *)var);
     }
 }
 
 
-void sgWriteLongLong ( gzFile fd, const long long int var )
+void sgWriteLongLong ( gzFile fd, const int64_t var )
 {
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned long long*)&var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint64_t *)&var);
     }
-    if ( gzwrite ( fd, (void *)(&var), sizeof(long long int) )
-         != sizeof(long long int) )
+    if ( gzwrite ( fd, (void *)(&var), sizeof(int64_t) )
+         != sizeof(int64_t) )
     {
         write_error = true ;
     }
@@ -222,16 +208,16 @@ void sgReadUShort ( gzFile fd, unsigned short *var )
     if ( gzread ( fd, var, sizeof(unsigned short) ) != sizeof(unsigned short) ){
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned short int*)var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint16_t *)var);
     }
 }
 
 
 void sgWriteUShort ( gzFile fd, const unsigned short var )
 {
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned short*)&var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint16_t *)&var);
     }
     if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned short) )
         != sizeof(unsigned short) )
@@ -246,16 +232,16 @@ void sgReadShort ( gzFile fd, short *var )
     if ( gzread ( fd, var, sizeof(short) ) != sizeof(short) ) {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned short int*)var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint16_t *)var);
     }
 }
 
 
 void sgWriteShort ( gzFile fd, const short var )
 {
-    if ( sgIsBigEndian ) {
-        sgEndianSwap( (unsigned short*)&var);
+    if ( sgIsBigEndian() ) {
+        sgEndianSwap( (uint16_t *)&var);
     }
     if ( gzwrite ( fd, (void *)(&var), sizeof(short) ) != sizeof(short) ) {
         write_error = true ;
@@ -268,9 +254,9 @@ void sgReadFloat ( gzFile fd, const unsigned int n, float *var )
     if ( gzread ( fd, var, sizeof(float) * n ) != (int)(sizeof(float) * n) ) {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned int*)var++);
+            sgEndianSwap( (uint32_t *)var++);
         }
     }
 }
@@ -278,12 +264,12 @@ void sgReadFloat ( gzFile fd, const unsigned int n, float *var )
 
 void sgWriteFloat ( gzFile fd, const unsigned int n, const float *var )
 {
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         float *swab = new float[n];
         float *ptr = swab;
         memcpy( swab, var, sizeof(float) * n );
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned int*)ptr++);
+            sgEndianSwap( (uint32_t *)ptr++);
         }
         var = swab;
     }
@@ -299,9 +285,9 @@ void sgReadDouble ( gzFile fd, const unsigned int n, double *var )
     if ( gzread ( fd, var, sizeof(double) * n ) != (int)(sizeof(double) * n) ) {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned long long*)var++);
+            sgEndianSwap( (uint64_t *)var++);
         }
     }
 }
@@ -309,12 +295,12 @@ void sgReadDouble ( gzFile fd, const unsigned int n, double *var )
 
 void sgWriteDouble ( gzFile fd, const unsigned int n, const double *var )
 {
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         double *swab = new double[n];
         double *ptr = swab;
         memcpy( swab, var, sizeof(double) * n );
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned long long*)ptr++);
+            sgEndianSwap( (uint64_t *)ptr++);
         }
         var = swab;
     }
@@ -349,9 +335,9 @@ void sgReadUShort ( gzFile fd, const unsigned int n, unsigned short *var )
     {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned short int*)var++);
+            sgEndianSwap( (uint16_t *)var++);
         }
     }
 }
@@ -359,12 +345,12 @@ void sgReadUShort ( gzFile fd, const unsigned int n, unsigned short *var )
 
 void sgWriteUShort ( gzFile fd, const unsigned int n, const unsigned short *var )
 {
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         unsigned short *swab = new unsigned short[n];
         unsigned short *ptr = swab;
         memcpy( swab, var, sizeof(unsigned short) * n );
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned short*)ptr++);
+            sgEndianSwap( (uint16_t *)ptr++);
         }
         var = swab;
     }
@@ -384,9 +370,9 @@ void sgReadShort ( gzFile fd, const unsigned int n, short *var )
     {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned short int*)var++);
+            sgEndianSwap( (uint16_t *)var++);
         }
     }
 }
@@ -394,12 +380,12 @@ void sgReadShort ( gzFile fd, const unsigned int n, short *var )
 
 void sgWriteShort ( gzFile fd, const unsigned int n, const short *var )
 {
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         short *swab = new short[n];
         short *ptr = swab;
         memcpy( swab, var, sizeof(short) * n );
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned short*)ptr++);
+            sgEndianSwap( (uint16_t *)ptr++);
         }
         var = swab;
     }
@@ -418,9 +404,9 @@ void sgReadUInt ( gzFile fd, const unsigned int n, unsigned int *var )
     {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned int*)var++);
+            sgEndianSwap( (uint32_t *)var++);
         }
     }
 }
@@ -428,12 +414,12 @@ void sgReadUInt ( gzFile fd, const unsigned int n, unsigned int *var )
 
 void sgWriteUInt ( gzFile fd, const unsigned int n, const unsigned int *var )
 {
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         unsigned int *swab = new unsigned int[n];
         unsigned int *ptr = swab;
         memcpy( swab, var, sizeof(unsigned int) * n );
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned int*)ptr++);
+            sgEndianSwap( (uint32_t *)ptr++);
         }
         var = swab;
     }
@@ -453,9 +439,9 @@ void sgReadInt ( gzFile fd, const unsigned int n, int *var )
     {
         read_error = true ;
     }
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned int*)var++);
+            sgEndianSwap( (uint32_t *)var++);
         }
     }
 }
@@ -463,12 +449,12 @@ void sgReadInt ( gzFile fd, const unsigned int n, int *var )
 
 void sgWriteInt ( gzFile fd, const unsigned int n, const int *var )
 {
-    if ( sgIsBigEndian ) {
+    if ( sgIsBigEndian() ) {
         int *swab = new int[n];
         int *ptr = swab;
         memcpy( swab, var, sizeof(int) * n );
         for ( unsigned int i = 0; i < n; ++i ) {
-            sgEndianSwap( (unsigned int*)ptr++);
+            sgEndianSwap( (uint32_t *)ptr++);
         }
         var = swab;
     }