binpac.h

Go to the documentation of this file.

// $Id: binpac.h,v 1.2 2005/09/07 17:33:56 vern Exp $

#ifndef binpac_h
#define binpac_h

#include <stdarg.h>
#include <stdio.h>
#include <string>

using namespace std;

namespace BinPAC
{

const int bigendian = 0;
const int littleendian = 1;

#ifndef pac_type_defs
#define pac_type_defs

typedef char            int8;
typedef short           int16;
typedef long            int32;
typedef unsigned char   uint8;
typedef unsigned short  uint16;
typedef unsigned long   uint32;

#endif /* pac_type_defs */

/* Handling byte order */

#include <sys/param.h>

#ifdef BYTE_ORDER
#  if BYTE_ORDER == BIG_ENDIAN
#    define HOST_BYTEORDER      bigendian
#  elif BYTE_ORDER == LITTLE_ENDIAN
#    define HOST_BYTEORDER      littleendian
#  else
#    error "Unknown BYTE_ORDER"
#  endif
#else
#  error "BYTE_ORDER is not defined"
#endif

static inline int16 pac_swap(int16 x)
        {
        return (x >> 8) | ((x & 0xff) << 8);
        }

static inline uint16 pac_swap(uint16 x)
        {
        return (x >> 8) | ((x & 0xff) << 8);
        }

static inline int32 pac_swap(int32 x)
        {
        return  (x >> 24) | 
                ((x & 0xff0000) >> 8) | 
                ((x & 0xff00) << 8) | 
                ((x & 0xff) << 24);
        }

static inline uint32 pac_swap(uint32 x)
        {
        return  (x >> 24) | 
                ((x & 0xff0000) >> 8) | 
                ((x & 0xff00) << 8) | 
                ((x & 0xff) << 24);
        }

// #define FixByteOrder(byteorder, x)   (byteorder == HOST_BYTEORDER ? (x) : pac_swap(x))

template <class T>
static inline T UnMarshall(const u_char *data, T &result,
                        int byteorder)
        {
        result = 0;
        for ( int i = 0; i < sizeof(T); ++i )
                result = ( result << 8 ) | 
                        data[byteorder == bigendian ? i : sizeof(T) - 1 - i];
        return result;
        }

static const char* do_fmt(const char* format, va_list ap)
        {
        static char buf[1024];
        vsnprintf(buf, sizeof(buf), format, ap);
        return buf;
        }

static const char* fmt(const char* format, ...)
        {
        va_list ap;
        va_start(ap, format);
        const char* r = do_fmt(format, ap);
        va_end(ap);
        return r;
        }

class Exception
{
public:
        Exception(const char* m = "")
                : msg_("BinPAC exception: ")
                {
                append(m);
#ifdef DEBUG
                // abort();
#endif
                }

        void append(string m)           { msg_ += m; }
        string msg() const              { return msg_; }
        const char* c_msg() const       { return msg().c_str(); }

protected:
        string msg_;
};

class ExceptionOutOfBound : public Exception
{
public:
        ExceptionOutOfBound(const char* where, int len_needed, int len_given)
                {
                append(fmt("out_of_bound: %s: %d > %d", 
                        where, len_needed, len_given));
                }
};

class ExceptionInvalidCase : public Exception
{
public:
        ExceptionInvalidCase(const char* arg_location, 
                        int arg_index, int arg_expected)
                : location(arg_location), 
                  index(arg_index), expected(arg_expected)
                {
                append(fmt("invalid case: %s: %d != %d",
                        location, index, expected));
                }

protected:
        const char* location;
        int index, expected;
};

class ExceptionInvalidCaseIndex : public Exception
{
public:
        ExceptionInvalidCaseIndex(const char* arg_location, 
                        int arg_index)
                : location(arg_location), 
                  index(arg_index)
                {
                append(fmt("invalid index for case: %s: %d",
                        location, index));
                }

protected:
        const char* location;
        int index;
};

class ExceptionInvalidOffset : public Exception
{
public:
        ExceptionInvalidOffset(const char* arg_location, 
                        int arg_min_offset, int arg_offset)
                : location(arg_location), 
                  min_offset(arg_min_offset), offset(arg_offset)
                {
                append(fmt("invalid offset: %s: min_offset = %d, offset = %d",
                        location, min_offset, offset));
                }

protected:
        const char* location;
        int min_offset, offset;
};

template <class T>
struct array
{
        T* v;
        int length;

        T const & operator[](int index) const   { check_index(index); return v[index]; }
        T & operator[](int index)       { check_index(index); return v[index]; }
        int size() const                { return length; }
        T const * begin() const         { return v; }
        T const * end() const           { return v + length; }

        void check_index(int index) const
                {
                if ( index < 0 || index >= size() )
                        throw Exception(fmt("array index out of bound: %d", index));
                }
};

template <class T>
static void make_array(array<T> &a, int len)
        {
        a.length = len;
        if ( len > 0 )
                a.v = new T[len];
        else
                a.v = 0;
        }

template <class T>
static void delete_array(array<T> &a)
        {
        delete [] a.v;
        a.v = 0;
        }

} // namespace BinPAC

#endif /* binpac_h */

---