binio.cc

Go to the documentation of this file.

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * binio.cpp - Binary stream I/O classes
 * Copyright (C) 2002, 2003 Simon Peter <dn.tlp@gmx.net>
 */
 
#include <cstring>
#include <stdexcept>
 
#include "binio.h"
 
#if BINIO_WITH_MATH
 
#include <cmath>
 
#ifdef __QNXNTO__
   #define pow std::powf
#endif // __QNXNTO__
 
// If 'math.h' doesn't define HUGE_VAL, we try to use HUGE instead.
#ifndef HUGE_VAL
# define HUGE_VAL HUGE
#endif
 
#endif
 
/***** Defines *****/
 
#if BINIO_ENABLE_STRING
// String buffer size for std::string readString() method
#define STRINGBUFSIZE   256
#endif
 
/***** binio *****/
 
const binio::Flags binio::system_flags = binio::detect_system_flags();
 
binio::Flags binio::detect_system_flags()
{
  Flags f = 0;
 
  // Endian test
  union {
    int word;
    Byte byte;
  } endian_test;
 
  endian_test.word = 1;
  if(endian_test.byte != 1) f |= BigEndian;
 
  // IEEE-754 floating-point test
  float fl = 6.5f;
  Byte  *dat = (Byte *)&fl;
 
  if(sizeof(float) == 4 && sizeof(double) == 8)
    {
      if(f & BigEndian)
        {
          if(dat[0] == 0x40 && dat[1] == 0xD0 && !dat[2] && !dat[3])
            f |= FloatIEEE;
        }
      else
        {
          if(dat[3] == 0x40 && dat[2] == 0xD0 && !dat[1] && !dat[0])
            f |= FloatIEEE;
        }
    }
 
  return f;
}
 
binio::binio()
  : my_flags(system_flags), err(NoError)
{
}
 
binio::~binio()
{
}
 
void binio::setFlag(Flag f, bool set)
{
  if(set)
    my_flags |= f;
  else
    my_flags &= !f;
}
 
bool binio::getFlag(Flag f)
{
  return (my_flags & f ? true : false);
}
 
binio::Error binio::error()
{
  Error e = err;
 
  err = NoError;
  return e;
}
 
bool binio::eof()
{
  return (err & Eof ? true : false);
}
 
/***** binistream *****/
 
binistream::binistream()
{
}
 
binistream::~binistream()
{
}
 
binistream::Int binistream::readInt(unsigned int size)
{
  unsigned int  i;
  Int           val = 0, in;
 
  // Check if 'size' doesn't exceed our system's biggest type.
  if(size > sizeof(Int)) {
    err |= Unsupported;
    throw runtime_error ("The size of the integer to be read exceeds our system's biggest type");
    return 0;
  }
 
  for(i = 0; i < size; i++) {
    in = getByte();
    if(getFlag(BigEndian))
      val <<= 8;
    else
      in <<= i * 8;
    val |= in;
  }
 
  return val;
}
 
binistream::Float binistream::readFloat(FType ft)
{
  if(getFlag(FloatIEEE))
    {
      // Read IEEE-754 floating-point value
 
      unsigned int      i=0;
      unsigned int      size=0;
      Byte              in[8];
      bool              swap;
 
      // Determine appropriate size for given type.
      switch(ft) {
        case Single: size = 4; break;   // 32 bits
        case Double: size = 8; break;   // 64 bits
      }
 
      // Determine byte ordering, depending on what we do next
      if(system_flags & FloatIEEE)
        swap = getFlag(BigEndian) ^ (system_flags & BigEndian);
      else
        swap = !getFlag(BigEndian);
 
      if (!swap && ((size == sizeof (float)) || (size == sizeof (double))))
        {
          if (size == 4)
            {
              float f;
              getRaw ((char *)&f, size);
              return (Float)f;
            }
          else
            {
              double d;
              getRaw ((char *)&d, size);
              return (Float)d;
            }
        }
      else
        {
          // Read the float byte by byte, converting endianess
          for(i = 0; i < size; i++)
            if(swap)
              in[size - i - 1] = getByte();
            else
              in[i] = getByte();
 
          if(system_flags & FloatIEEE) {
                // Compatible system, let the hardware do the conversion
                switch(ft) {
                  case Single: return *(float *)in;
                  case Double: return *(double *)in;
                }
          } else {      // Incompatible system, convert manually
                switch(ft) {
                  case Single: return ieee_single2float(in);
                  case Double: return ieee_double2float(in);
                }
          }
        }
    }
 
  // User tried to read a (yet) unsupported floating-point type. Bail out.
  err |= Unsupported; return 0.0;
}
 
binistream::Float binistream::ieee_single2float(Byte *data)
{
  signed int    sign = data[0] >> 7 ? -1 : 1;
  unsigned int  exp = ((data[0] << 1) & 0xff) | ((data[1] >> 7) & 1),
    fracthi7 = data[1] & 0x7f;
  Float         fract = fracthi7 * 65536.0 + data[2] * 256.0 + data[3];
 
  // Signed and unsigned zero
  if(!exp && !fracthi7 && !data[2] && !data[3]) return sign * 0.0;
 
  // Signed and unsigned infinity (maybe unsupported on non-IEEE systems)
  if(exp == 255)
    {
      if(!fracthi7 && !data[2] && !data[3])
        {
#ifdef HUGE_VAL
          if(sign == -1) return -HUGE_VAL; else return HUGE_VAL;
#else
          err |= Unsupported;
          if(sign == -1) return -1.0; else return 1.0;
#endif
        }
      else
        {         // Not a number (maybe unsupported on non-IEEE systems)
#ifdef NAN
          return NAN;
#else
          err |= Unsupported; return 0.0;
#endif
        }
    }
 
  if(!exp)      // Unnormalized float values
    return sign * pow(2, -126.) * fract * pow(2, -23.);
  else          // Normalized float values
    return sign * pow(2, exp - 127.) * (fract * pow(2, -23.) + 1);
 
  err |= Fatal; return 0.0;
}
 
binistream::Float binistream::ieee_double2float(Byte *data)
{
  signed int    sign = data[0] >> 7 ? -1 : 1;
  unsigned int  exp = ((unsigned int)(data[0] & 0x7f) << 4) | (data[1] >> 4),
    fracthi4 = data[1] & 0xf;
  Float         fract = fracthi4 * pow(2, 48.) + data[2] * pow(2, 40.) + data[3] *
    pow(2, 32.) + data[4] * pow(2, 24.) + data[5] * pow(2, 16.) + data[6] *
    pow(2, 8.) + data[7];
 
  // Signed and unsigned zero
  if(!exp && !fracthi4 && !data[2] && !data[3] && !data[4] && !data[5] &&
     !data[6] && !data[7]) return sign * 0.0;
 
  // Signed and unsigned infinity  (maybe unsupported on non-IEEE systems)
  if(exp == 2047)
    {
      if(!fracthi4 && !data[2] && !data[3] && !data[4] && !data[5] && !data[6] &&
         !data[7])
        {
#ifdef HUGE_VAL
          if(sign == -1) return -HUGE_VAL; else return HUGE_VAL;
#else
          err |= Unsupported;
          if(sign == -1) return -1.0; else return 1.0;
#endif
        }
      else
        {         // Not a number (maybe unsupported on non-IEEE systems)
#ifdef NAN
          return NAN;
#else
          err |= Unsupported; return 0.0;
#endif
        }
    }
 
  if(!exp)      // Unnormalized float values
    return sign * pow(2, -1022.) * fract * pow(2, -52.);
  else          // Normalized float values
    return sign * pow(2, exp - 1023.) * (fract * pow(2, -52.) + 1);
 
  err |= Fatal; return 0.0;
}
 
#if !BINIO_WITH_MATH
binio::Float binio::pow(Float base, signed int exp)
/* Our own, stripped-down version of pow() for not having to depend on 'math.h'.
 * This one handles float values for the base and an integer exponent, both
 * positive and negative.
 */
{
  int   i;
  Float val = base;
 
  if(!exp) return 1.0;
 
  for(i = 1; i < (exp < 0 ? -exp : exp); i++)
    val *= base;
 
  if(exp < 0) val = 1.0 / val;
 
  return val;
}
#endif
 
unsigned long binistream::readString(char *str, unsigned long maxlen)
{
  unsigned long i;
 
  for(i = 0; i < maxlen; i++) {
    str[i] = (char)getByte();
    if(err) { str[i] = '\0'; return i; }
  }
 
  return maxlen;
}
 
unsigned long binistream::readString(char *str, unsigned long maxlen,
                                     const char delim)
{
  unsigned long i;
 
  for(i = 0; i < maxlen; i++) {
    str[i] = (char)getByte();
    if(str[i] == delim || err) { str[i] = '\0'; return i; }
  }
 
  str[maxlen] = '\0';
  return maxlen;
}
 
#if BINIO_ENABLE_STRING
std::string binistream::readString(const char delim)
{
  char buf[STRINGBUFSIZE + 1];
  std::string tempstr;
  unsigned long read;
 
  do {
    read = readString(buf, STRINGBUFSIZE, delim);
    tempstr.append(buf, read);
  } while(read == STRINGBUFSIZE);
 
  return tempstr;
}
#endif
 
binistream::Int binistream::peekInt(unsigned int size)
{
  Int val = readInt(size);
  if(!err) seek(-(long)size, Add);
  return val;
}
 
binistream::Float binistream::peekFloat(FType ft)
{
  Float val = readFloat(ft);
 
  if(!err)
    switch(ft) {
    case Single: seek(-4, Add); break;
    case Double: seek(-8, Add); break;
    }
 
  return val;
}
 
bool binistream::ateof()
{
  Error olderr = err;   // Save current error state
  bool  eof_then;
 
  peekInt(1);
  eof_then = eof();     // Get error state of next byte
  err = olderr;         // Restore original error state
  return eof_then;
}
 
void binistream::ignore(unsigned long amount)
{
  unsigned long i;
 
  for(i = 0; i < amount; i++)
    getByte();
}
 
/***** binostream *****/
 
binostream::binostream()
{
}
 
binostream::~binostream()
{
}
 
void binostream::writeInt(Int val, unsigned int size)
{
  unsigned int  i;
 
  // Check if 'size' doesn't exceed our system's biggest type.
  if(size > sizeof(Int)) {
    err |= Unsupported;
    throw runtime_error ("The size of the integer to be stored exceeds our system's biggest type");
    return;
  }
 
  for(i = 0; i < size; i++) {
    if(getFlag(BigEndian))
      putByte((unsigned char)(val >> ((size - i - 1) * 8)) & 0xff);
    else {
      putByte((unsigned char)val & 0xff);
      val >>= 8;
    }
  }
}
 
void binostream::writeFloat(Float f, FType ft)
{
  if(getFlag(FloatIEEE)) {      // Write IEEE-754 floating-point value
    
    unsigned int        i=0;
    unsigned int        size=0;
    Byte                *out=NULL;
    bool                swap;
 
    if(system_flags & FloatIEEE) {
      // compatible system, let the hardware do the conversion
      float     outf = (float)f;
      double    outd = (double)f;
 
      // Hardware could be big or little endian, convert appropriately
      swap = getFlag(BigEndian) ^ (system_flags & BigEndian);
 
      switch(ft) {
        case Single: size = 4; break;   // 32 bits
        case Double: size = 8; break;   // 64 bits
      }
 
      if (!swap && ((size == sizeof (float)) || (size == sizeof (double))))
        {
          if (size == 4)
            { putRaw ((char *)&outf, size); return; }
          else
            { putRaw ((char *)&outd, size); return; }
        }
      else
        {
          // Determine appropriate size for given type and convert by hardware
          switch(ft) {
            case Single: out = (Byte *)&outf; break;    // 32 bits
            case Double: out = (Byte *)&outd; break;    // 64 bits
          }
        }
    } else {
#if BINIO_WITH_MATH
      // incompatible system, do the conversion manually
      Byte      buf[8];
 
      // Our own value is always big endian, just check whether we have to
      // convert for a different stream format.
      swap = !getFlag(BigEndian);
 
      // Convert system's float to requested IEEE-754 float
      switch(ft) {
      case Single: size = 4; float2ieee_single(f, buf); break;
      case Double: size = 8; float2ieee_double(f, buf); break;
      }
 
      out = buf;        // Make the value ready for writing
#else
      // No necessary support routines to do the conversion, bail out!
      err |= Unsupported; return;
#endif
    }
 
    // Write the float byte by byte, converting endianess
    if(swap) out += size - 1;
    for(i = 0; i < size; i++) {
      putByte(*out);
      if(swap) out--; else out++;
    }
 
    return;     // We're done.
  }
 
  // User tried to write an unsupported floating-point type. Bail out.
  err |= Unsupported;
}
 
#ifdef BINIO_WITH_MATH
 
/*
 * Single and double floating-point to IEEE-754 equivalent conversion functions
 * courtesy of Ken Turkowski.
 *
 * Copyright (C) 1989-1991 Ken Turkowski. <turk@computer.org>
 *
 * All rights reserved.
 *
 * Warranty Information
 *  Even though I have reviewed this software, I make no warranty
 *  or representation, either express or implied, with respect to this
 *  software, its quality, accuracy, merchantability, or fitness for a
 *  particular purpose.  As a result, this software is provided "as is,"
 *  and you, its user, are assuming the entire risk as to its quality
 *  and accuracy.
 *
 * This code may be used and freely distributed as long as it includes
 * this copyright notice and the above warranty information.
 */
 
/****************************************************************
 * The following two routines make up for deficiencies in many
 * compilers to convert properly between unsigned integers and
 * floating-point.  Some compilers which have this bug are the
 * THINK_C compiler for the Macintosh and the C compiler for the
 * Silicon Graphics MIPS-based Iris.
 ****************************************************************/
 
#ifdef applec   /* The Apple C compiler works */
# define FloatToUnsigned(f)     ((unsigned long)(f))
#else
# define FloatToUnsigned(f)     ((unsigned long)(((long)((f) - 2147483648.0)) + 2147483647L + 1))
#endif
 
#define SEXP_MAX        255
#define SEXP_OFFSET     127
#define SEXP_SIZE       8
#define SEXP_POSITION   (32-SEXP_SIZE-1)
 
void binostream::float2ieee_single(Float num, Byte *bytes)
{
  long          sign;
  register long bits;
 
  if (num < 0) {        /* Can't distinguish a negative zero */
    sign = 0x80000000;
    num *= -1;
  } else {
    sign = 0;
  }
 
  if (num == 0) {
    bits = 0;
  } else {
    Float       fMant;
    int         expon;
 
    fMant = frexp(num, &expon);
 
    if ((expon > (SEXP_MAX-SEXP_OFFSET+1)) || !(fMant < 1)) {
      /* NaN's and infinities fail second test */
      bits = sign | 0x7F800000;         /* +/- infinity */
    }
 
    else {
      long mantissa;
 
      if (expon < -(SEXP_OFFSET-2)) {   /* Smaller than normalized */
        int shift = (SEXP_POSITION+1) + (SEXP_OFFSET-2) + expon;
        if (shift < 0) {        /* Way too small: flush to zero */
          bits = sign;
        }
        else {                  /* Nonzero denormalized number */
          mantissa = (long)(fMant * (double)(1L << shift));
          bits = sign | mantissa;
        }
      }
 
      else {                            /* Normalized number */
        mantissa = (long)floor(fMant * (1L << (SEXP_POSITION+1)));
        mantissa -= (1L << SEXP_POSITION);                      /* Hide MSB */
        bits = sign | ((long)((expon + SEXP_OFFSET - 1)) << SEXP_POSITION) | mantissa;
      }
    }
  }
 
  bytes[0] = (unsigned char)(bits >> 24);       /* Copy to byte string */
  bytes[1] = (unsigned char)(bits >> 16);
  bytes[2] = (unsigned char)(bits >> 8);
  bytes[3] = (unsigned char)bits;
}
 
#define DEXP_MAX        2047
#define DEXP_OFFSET     1023
#define DEXP_SIZE       11
#define DEXP_POSITION   (32-DEXP_SIZE-1)
 
void binostream::float2ieee_double(Float num, Byte *bytes)
{
  long  sign;
  long  first, second;
 
  if (num < 0) {        /* Can't distinguish a negative zero */
    sign = 0x80000000;
    num *= -1;
  } else {
    sign = 0;
  }
 
  if (num == 0) {
    first = 0;
    second = 0;
  } else {
    Float       fMant, fsMant;
    int         expon;
 
    fMant = frexp(num, &expon);
 
    if ((expon > (DEXP_MAX-DEXP_OFFSET+1)) || !(fMant < 1)) {
      /* NaN's and infinities fail second test */
      first = sign | 0x7FF00000;                /* +/- infinity */
      second = 0;
    }
 
    else {
      long mantissa;
 
      if (expon < -(DEXP_OFFSET-2)) {   /* Smaller than normalized */
        int shift = (DEXP_POSITION+1) + (DEXP_OFFSET-2) + expon;
        if (shift < 0) {        /* Too small for something in the MS word */
          first = sign;
          shift += 32;
          if (shift < 0) {      /* Way too small: flush to zero */
            second = 0;
          }
          else {                        /* Pretty small demorn */
            second = FloatToUnsigned(floor(ldexp(fMant, shift)));
          }
        }
        else {                  /* Nonzero denormalized number */
          fsMant = ldexp(fMant, shift);
          mantissa = (long)floor(fsMant);
          first = sign | mantissa;
          second = FloatToUnsigned(floor(ldexp(fsMant - (double)mantissa, 32)));
        }
      }
 
      else {                            /* Normalized number */
        fsMant = ldexp(fMant, DEXP_POSITION+1);
        mantissa = (long)floor(fsMant);
        mantissa -= (1L << DEXP_POSITION);                      /* Hide MSB */
        fsMant -= (1L << DEXP_POSITION);
        first = sign | ((long)((expon + DEXP_OFFSET - 1)) << DEXP_POSITION) | mantissa;
        second = FloatToUnsigned(floor(ldexp(fsMant - (double)mantissa, 32)));
      }
    }
  }
 
  bytes[0] = (unsigned char)(first >> 24);
  bytes[1] = (unsigned char)(first >> 16);
  bytes[2] = (unsigned char)(first >> 8);
  bytes[3] = (unsigned char)first;
  bytes[4] = (unsigned char)(second >> 24);
  bytes[5] = (unsigned char)(second >> 16);
  bytes[6] = (unsigned char)(second >> 8);
  bytes[7] = (unsigned char)second;
}
 
#endif // BINIO_WITH_MATH
 
unsigned long binostream::writeString(const char *str, unsigned long amount)
{
  unsigned int i;
 
  if(!amount) amount = strlen(str);
 
  for(i = 0; i < amount; i++) {
    putByte(str[i]);
    if(err) return i;
  }
 
  return amount;
}
 
#if BINIO_ENABLE_STRING
unsigned long binostream::writeString(const std::string &str)
{
  return writeString(str.c_str());
}
#endif