GitHub-Mirror/NeoStats
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-12. You can view files and clone it, but cannot push or open issues or pull requests.
NeoStats/include/MuscleSupport.h

841 lines
31 KiB
C++
Raw Permalink Blame History

/* NeoStats - IRC Statistical Services
** Copyright (c) 1999-2008 Adam Rutter, Justin Hammond, Mark Hetherington
** http://www.neostats.net/
**
** Portions Copyright (c) 2000 - 2001 ^Enigma^
**
** 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
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program 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 General Public License for more details.
**
** 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
** USA
**
** NeoStats CVS Identification
** $Id$
*/
/* This file is Copyright 2007 Meyer Sound Laboratories Inc. See the included LICENSE.txt file for details. */
/******************************************************************************
/
/ File: MuscleSupport.h
/
/ Description: Standard types, macros, etc, for MUSCLE.
/ Many of them are suspiciously BeOS-like. ;^)
/
*******************************************************************************/
#ifndef MuscleSupport_h
#define MuscleSupport_h
#define MUSCLE_VERSION_STRING "3.25b"
#include <string.h> /* for memcpy() */
/* Define this if the default FD_SETSIZE is too small for you (i.e. under Windows it's only 64) */
#if defined(MUSCLE_FD_SETSIZE)
# if defined(FD_SETSIZE)
# error "MuscleSupport.h: Can't redefine FD_SETSIZE, someone else has already defined it! You need to include MuscleSupport.h before including any other header files that define FD_SETSIZE."
# else
# define FD_SETSIZE MUSCLE_FD_SETSIZE
# endif
#endif
/* If we are in an environment where known assembly is available, make a note of that fact */
#ifndef MUSCLE_AVOID_INLINE_ASSEMBLY
# if defined(__GNUC__)
# if defined(__i386__)
# define MUSCLE_USE_X86_INLINE_ASSEMBLY 1
# elif defined(__PPC__) || defined(__POWERPC__)
# define MUSCLE_USE_POWERPC_INLINE_ASSEMBLY 1
# endif
# endif
# if defined(_MSC_VER) && defined(_X86_)
# define MUSCLE_USE_X86_INLINE_ASSEMBLY 1
# endif
#endif
#ifndef __cplusplus
# define MUSCLE_AVOID_NAMESPACES
# define NEW_H_NOT_AVAILABLE
#endif
/* Since certain antique compilers don't support namespaces, we
* do all namespace-related declarations via macros which can
* be no-op'd out by declaring -DMUSCLE_AVOID_NAMESPACES in the Makefile.
*/
#ifdef MUSCLE_AVOID_NAMESPACES
# define DECLARE_NAMESPACE(x)
# define BEGIN_NAMESPACE(x)
# define END_NAMESPACE(x)
# define USING_NAMESPACE(x)
#else
# define DECLARE_NAMESPACE(x) namespace x {};
# define BEGIN_NAMESPACE(x) namespace x {
# define END_NAMESPACE(x) };
# define USING_NAMESPACE(x) using namespace x;
#endif
/* Just declare the muscle namespace as existing.
* If we ever decide to make the muscle namespace a superset
* of another namespace, we would add a 'using namespace' line here.
*/
DECLARE_NAMESPACE(muscle);
/* these CPUs can't handle non-aligned word reads, so we'll accomodate them by using memcpy() instead. */
#if defined(MIPS) || defined(mc68000) || defined(sparc) || defined(__sparc) || defined(m68k) || defined(__68k__) || defined(__sparc__)
# define MUSCLE_CPU_REQUIRES_DATA_ALIGNMENT
#endif
/* Borland C++ builder also runs under Win32, but it doesn't set this flag So we'd better set it ourselves. */
#if defined(__BORLANDC__) || defined(__WIN32__) || defined(_MSC_VER)
# ifndef WIN32
# define WIN32 1
# endif
#endif
/* Win32 can't handle this stuff, it's too lame */
#ifdef WIN32
# define UNISTD_H_NOT_AVAILABLE
# ifndef _MSC_VER /* 7/3/2006: Mika's patch allows VC++ to use newnothrow */
# define NEW_H_NOT_AVAILABLE
# endif
#endif
#ifndef UNISTD_H_NOT_AVAILABLE
# include <unistd.h>
#endif
#ifndef NEW_H_NOT_AVAILABLE
# include <new>
# ifndef MUSCLE_AVOID_NAMESPACES
# ifndef __MWERKS__
using std::bad_alloc;
using std::nothrow_t;
using std::nothrow;
# if (defined(_MSC_VER))
// VC++ 6.0 and earlier lack this definition
# if (_MSC_VER <= 1200)
inline void __cdecl operator delete(void *p, const std::nothrow_t&) _THROW0() {delete(p);}
# endif
# else
using std::new_handler;
using std::set_new_handler;
# endif
# endif
# endif
#else
# define MUSCLE_AVOID_NEWNOTHROW
#endif
#ifndef newnothrow
# ifdef MUSCLE_AVOID_NEWNOTHROW
# define newnothrow new
# else
# define newnothrow new (nothrow)
# endif
#endif
/* Unfortunately, the 64-bit printf() format specifier is different for different compilers :^P */
#if defined(__MWERKS__) || defined(WIN32) || defined(__BORLANDC__) || defined(__BEOS__)
# if (_MSC_VER == 1200)
# define INT64_FORMAT_SPEC "%I64i"
# define UINT64_FORMAT_SPEC "%I64u"
# else
# define INT64_FORMAT_SPEC "%Li"
# define UINT64_FORMAT_SPEC "%Lu"
# endif
#else
# define INT64_FORMAT_SPEC "%lli"
# define UINT64_FORMAT_SPEC "%llu"
#endif
#ifdef __BEOS__
# include <kernel/debugger.h>
# define MCRASH_IMPL debugger("muscle assertion failure")
#elif defined(WIN32)
# if defined(UNICODE)
# define MCRASH_IMPL FatalAppExit(0, L"muscle assertion failure")
# else
# define MCRASH_IMPL FatalAppExit(0, "muscle assertion failure")
# endif
#else
# define MCRASH_IMPL *((uint32*)NULL) = 0x666
#endif
#ifdef MUSCLE_AVOID_ASSERTIONS
# define MASSERT(x,msg)
#else
# define MASSERT(x,msg) {if(!(x)) MCRASH(msg)}
#endif
#ifdef MUSCLE_AVOID_NAMESPACES
# define MCRASH(msg) {LogTime(MUSCLE_LOG_CRITICALERROR, "ASSERTION FAILED: (%s:%i) %s\n", __FILE__,__LINE__,msg); LogStackTrace(MUSCLE_LOG_CRITICALERROR); MCRASH_IMPL;}
# define WARN_OUT_OF_MEMORY LogTime(MUSCLE_LOG_CRITICALERROR, "ERROR--OUT OF MEMORY! (%s:%i)\n",__FILE__,__LINE__)
# define MCHECKPOINT LogTime(MUSCLE_LOG_WARNING, "Reached checkpoint at %s:%i\n", __FILE__, __LINE__)
#else
# define MCRASH(msg) {muscle::LogTime(muscle::MUSCLE_LOG_CRITICALERROR, "ASSERTION FAILED: (%s:%i) %s\n", __FILE__,__LINE__,msg); muscle::LogStackTrace(MUSCLE_LOG_CRITICALERROR); MCRASH_IMPL;}
# define WARN_OUT_OF_MEMORY muscle::LogTime(muscle::MUSCLE_LOG_CRITICALERROR, "ERROR--OUT OF MEMORY! (%s:%i)\n",__FILE__,__LINE__)
# define MCHECKPOINT muscle::LogTime(muscle::MUSCLE_LOG_WARNING, "Reached checkpoint at %s:%i\n", __FILE__, __LINE__)
#endif
#define UNLESS(x) if(!(x))
#define ARRAYITEMS(x) (sizeof(x)/sizeof(x[0])) /* returns # of items in array */
typedef void * muscleVoidPointer; /* it's a bit easier, syntax-wise, to use this type than (void *) directly in some cases. */
#ifdef __BEOS__
# include <support/Errors.h>
# include <support/ByteOrder.h> /* might as well use the real thing (and avoid complaints about duplication) */
# include <support/SupportDefs.h>
# include <support/TypeConstants.h>
# ifdef BONE
# define closesocket close
# else
# define BEOS_OLD_NETSERVER
# endif
#else
# define B_ERROR -1
# define B_NO_ERROR 0
# define B_OK B_NO_ERROR
# ifndef WIN32
# define closesocket close
# endif
# ifdef __ATHEOS__
# include </ainc/atheos/types.h>
# else
# ifndef MUSCLE_TYPES_PREDEFINED /* certain (ahem) projects already set these themselves... */
# define true 1
# define false 0
typedef signed char int8;
typedef unsigned char uint8;
typedef short int16;
typedef unsigned short uint16;
# if defined(__osf__) /* some 64bit systems will have long=64-bit, int=32-bit */
typedef int int32;
typedef unsigned int uint32;
# elif defined(__amd64__) /* some 64bit systems will have long=64-bit, int=32-bit */
typedef int int32;
typedef unsigned int uint32;
# else
typedef long int32;
typedef unsigned long uint32;
# endif
# if defined(WIN32) && !defined(__GNUWIN32__)
typedef __int64 int64;
typedef unsigned __int64 uint64;
# else
typedef long long int64;
typedef unsigned long long uint64;
# endif
typedef unsigned char uchar;
typedef unsigned short unichar;
typedef int32 status_t;
# endif /* !MUSCLE_TYPES_PREDEFINED */
# endif /* !__ATHEOS__*/
#endif /* __BEOS__*/
#define MAKETYPE(x) ((((unsigned long)(x[0])) << 24) | \
(((unsigned long)(x[1])) << 16) | \
(((unsigned long)(x[2])) << 8) | \
(((unsigned long)(x[3])) << 0))
#ifndef __BEOS__
/* Be-style message-field type codes.
* I've calculated the integer equivalents for these codes
* because gcc whines like a little girl about the four-byte
* constants when compiling under Linux --jaf
*/
enum {
B_ANY_TYPE = 1095653716, /* 'ANYT' = wild card */
B_BOOL_TYPE = 1112493900, /* 'BOOL' = boolean (1 byte per bool) */
B_DOUBLE_TYPE = 1145195589, /* 'DBLE' = double-precision float (8 bytes per double) */
B_FLOAT_TYPE = 1179406164, /* 'FLOT' = single-precision float (4 bytes per float) */
B_INT64_TYPE = 1280069191, /* 'LLNG' = long long integer (8 bytes per int) */
B_INT32_TYPE = 1280265799, /* 'LONG' = long integer (4 bytes per int) */
B_INT16_TYPE = 1397248596, /* 'SHRT' = short integer (2 bytes per int) */
B_INT8_TYPE = 1113150533, /* 'BYTE' = byte integer (1 byte per int) */
B_MESSAGE_TYPE = 1297303367, /* 'MSGG' = sub Message objects (reference counted) */
B_POINTER_TYPE = 1347310674, /* 'PNTR' = pointers (will not be flattened) */
B_POINT_TYPE = 1112559188, /* 'BPNT' = Point objects (each Point has two floats) */
B_RECT_TYPE = 1380270932, /* 'RECT' = Rect objects (each Rect has four floats) */
B_STRING_TYPE = 1129534546, /* 'CSTR' = String objects (variable length) */
B_OBJECT_TYPE = 1330664530, /* 'OPTR' = Flattened user objects (obsolete) */
B_RAW_TYPE = 1380013908, /* 'RAWT' = Raw data (variable number of bytes) */
B_MIME_TYPE = 1296649541 /* 'MIME' = MIME strings (obsolete) */
};
#endif
/* This one isn't defined by BeOS, so we have to enumerate it separately. */
enum {
B_TAG_TYPE = 1297367367 /* 'MTAG' = new for v2.00; for in-mem-only tags */
};
/* This constant is used in various places to mean 'as much as you want' */
#define MUSCLE_NO_LIMIT ((uint32)-1)
#ifdef __cplusplus
/** A handy little method to swap the bytes of any int-style datatype around */
template<typename T> inline T muscleSwapBytes(T swapMe)
{
union {T _iWide; uint8 _i8[sizeof(T)];} u1, u2;
u1._iWide = swapMe;
int i = 0;
int numBytes = sizeof(T);
while(numBytes>0) u2._i8[i++] = u1._i8[--numBytes];
return u2._iWide;
}
/* This template safely copies a value in from an untyped byte buffer to a typed value.
* (Make sure MUSCLE_CPU_REQUIRES_DATA_ALIGNMENT is defined if you are on a CPU
* that doesn't like non-word-aligned data reads and writes)
*/
template<typename T> inline void muscleCopyIn(T & dest, const void * source)
{
#ifdef MUSCLE_CPU_REQUIRES_DATA_ALIGNMENT
memcpy(&dest, source, sizeof(dest));
#else
dest = *((const T*)source);
#endif
}
/** This template safely copies a value in from a typed value to an untyped byte buffer.
* (Make sure MUSCLE_CPU_REQUIRES_DATA_ALIGNMENT is defined if you are on a CPU
* that doesn't like non-word-aligned data reads and writes)
*/
template<typename T> inline void muscleCopyOut(void * dest, const T & source)
{
#ifdef MUSCLE_CPU_REQUIRES_DATA_ALIGNMENT
memcpy(dest, &source, sizeof(source));
#else
*((T*)dest) = source;
#endif
}
/** This macro should be used instead of "newnothrow T[count]". It works the
* same, except that it hacks around an ugly bug in gcc 3.x where newnothrow
* would return ((T*)0x4) on memory failure instead of NULL.
* See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=10300
*/
#if __GNUC__ == 3
template <typename T> inline T * broken_gcc_newnothrow_array(size_t count)
{
T * ret = newnothrow T[count];
return (ret <= (T *)(sizeof(void *))) ? NULL : ret;
}
# define newnothrow_array(T, count) broken_gcc_newnothrow_array<T>(count)
#else
# define newnothrow_array(T, count) newnothrow T[count]
#endif
/** Returns the smallest of the two arguments */
template<typename T> inline const T & muscleMin(const T & p1, const T & p2) {return (p1 < p2) ? p1 : p2;}
/** Returns the smallest of the three arguments */
template<typename T> inline const T & muscleMin(const T & p1, const T & p2, const T & p3) {return muscleMin(p3, muscleMin(p1, p2));}
/** Returns the smallest of the four arguments */
template<typename T> inline const T & muscleMin(const T & p1, const T & p2, const T & p3, const T & p4) {return muscleMin(p3, p4, muscleMin(p1, p2));}
/** Returns the smallest of the five arguments */
template<typename T> inline const T & muscleMin(const T & p1, const T & p2, const T & p3, const T & p4, const T & p5) {return muscleMin(p3, p4, p5, muscleMin(p1, p2));}
/** Returns the largest of the two arguments */
template<typename T> inline const T & muscleMax(const T & p1, const T & p2) {return (p1 < p2) ? p2 : p1;}
/** Returns the largest of the three arguments */
template<typename T> inline const T & muscleMax(const T & p1, const T & p2, const T & p3) {return muscleMax(p3, muscleMax(p1, p2));}
/** Returns the largest of the four arguments */
template<typename T> inline const T & muscleMax(const T & p1, const T & p2, const T & p3, const T & p4) {return muscleMax(p3, p4, muscleMax(p1, p2));}
/** Returns the largest of the five arguments */
template<typename T> inline const T & muscleMax(const T & p1, const T & p2, const T & p3, const T & p4, const T & p5) {return muscleMax(p3, p4, p5, muscleMax(p1, p2));}
/** Swaps the two arguments */
template<typename T> inline void muscleSwap(T & p1, T & p2) {T t = p1; p1 = p2; p2 = t;}
/** Returns the value nearest to (v) that is still in the range [lo, hi]. */
template<typename T> inline const T & muscleClamp(const T & v, const T & lo, const T & hi) {return (v < lo) ? lo : ((v > hi) ? hi : v);}
/** Returns true iff (v) is in the range [lo,hi]. */
template<typename T> inline bool muscleInRange(const T & v, const T & lo, const T & hi) {return ((v >= lo)&&(v <= hi));}
/** Returns -1 if arg1 is larger, or 1 if arg2 is larger, or 0 if they are equal. */
template<typename T> inline int muscleCompare(const T & arg1, const T & arg2) {return (arg1>arg2) ? 1 : ((arg1<arg2) ? -1 : 0);}
/** Returns the absolute value of (arg) */
template<typename T> inline T muscleAbs(const T & arg) {return (arg<0)?(-arg):arg;}
/** Rounds the given float to the nearest integer value. */
inline int muscleRintf(float f) {return (f>=0.0f) ? ((int)(f+0.5f)) : -((int)((-f)+0.5f));}
/** Returns -1 if the value is less than zero, +1 if it is greater than zero, or 0 otherwise. */
template<typename T> inline int muscleSgn(const T & arg) {return (arg<0)?-1:((arg>0)?1:0);}
#endif /* __cplusplus */
#ifndef __BEOS__
/*
* Copyright(c) 1983, 1989
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* from nameser.h 8.1 (Berkeley) 6/2/93
*/
#ifndef BYTE_ORDER
#if (BSD >= 199103)
#include <machine/endian.h>
#else
#ifdef linux
#include <endian.h>
#else
#define LITTLE_ENDIAN 1234 /* least-significant byte first (vax, pc) */
#define BIG_ENDIAN 4321 /* most-significant byte first (IBM, net) */
#if defined(vax) || defined(ns32000) || defined(sun386) || defined(i386) || \
defined(__i386) || defined(__ia64) || \
defined(MIPSEL) || defined(_MIPSEL) || defined(BIT_ZERO_ON_RIGHT) || \
defined(__alpha__) || defined(__alpha) || defined(__CYGWIN__) || \
defined(_M_IX86) || defined(__GNUWIN32__) || defined(__LITTLEENDIAN__) || \
(defined(__Lynx__) && defined(__x86__))
#define BYTE_ORDER LITTLE_ENDIAN
#endif
#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || \
defined(__sparc) || \
defined(is68k) || defined(tahoe) || defined(ibm032) || defined(ibm370) || \
defined(MIPSEB) || defined(_MIPSEB) || defined(_IBMR2) || defined(DGUX) ||\
defined(apollo) || defined(__convex__) || defined(_CRAY) || \
defined(__hppa) || defined(__hp9000) || \
defined(__hp9000s300) || defined(__hp9000s700) || \
defined(__hp3000s900) || defined(MPE) || \
defined(BIT_ZERO_ON_LEFT) || defined(m68k) || \
(defined(__Lynx__) && \
(defined(__68k__) || defined(__sparc__) || defined(__powerpc__)))
#define BYTE_ORDER BIG_ENDIAN
#endif
#endif /* linux */
#endif /* BSD */
#endif /* BYTE_ORDER */
#if !defined(BYTE_ORDER) || (BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN)
/*
* you must determine what the correct bit order is for
* your compiler - the next line is an intentional error
* which will force your compiles to bomb until you fix
* the above macros.
*/
# error "Undefined or invalid BYTE_ORDER -- you will need to modify MuscleSupport.h to correct this";
#endif
/* End replacement code from Sun/University of California */
# if defined(MUSCLE_USE_POWERPC_INLINE_ASSEMBLY)
static inline uint16 MusclePowerPCSwapInt16(uint16 val)
{
uint16 a;
uint16 * addr = &a;
__asm__ ("sthbrx %1,0,%2" : "=m" (*addr) : "r" (val), "r" (addr));
return a;
}
static inline uint32 MusclePowerPCSwapInt32(uint32 val)
{
uint32 a;
uint32 * addr = &a;
__asm__ ("stwbrx %1,0,%2" : "=m" (*addr) : "r" (val), "r" (addr));
return a;
}
static inline float MusclePowerPCSwapFloat(float val)
{
float a;
float * addr = &a;
__asm__ ("stwbrx %1,0,%2" : "=m" (*addr) : "r" (val), "r" (addr));
return a;
}
static inline uint64 MusclePowerPCSwapInt64(uint64 val)
{
return ((uint64)(MusclePowerPCSwapInt32((uint32)((val>>32)&0xFFFFFFFF))))|(((uint64)(MusclePowerPCSwapInt32((uint32)(val&0xFFFFFFFF))))<<32);
}
static inline double MusclePowerPCSwapDouble(double val)
{
union {
double _dv;
uint64 _iv;
} u;
u._dv = val;
u._iv = MusclePowerPCSwapInt64(u._iv);
return u._dv;
}
# define B_SWAP_DOUBLE(arg) MusclePowerPCSwapDouble((double)(arg))
# define B_SWAP_FLOAT(arg) MusclePowerPCSwapFloat((float)(arg))
# define B_SWAP_INT64(arg) MusclePowerPCSwapInt64((uint64)(arg))
# define B_SWAP_INT32(arg) MusclePowerPCSwapInt32((uint32)(arg))
# define B_SWAP_INT16(arg) MusclePowerPCSwapInt16((uint16)(arg))
# elif defined(MUSCLE_USE_X86_INLINE_ASSEMBLY)
static inline uint16 MuscleX86SwapInt16(uint16 val)
{
#ifdef _MSC_VER
__asm {
mov ax, val;
xchg al, ah;
mov val, ax;
};
#else
__asm__ ("xchgb %b0,%h0" : "=q" (val) : "0" (val));
#endif
return val;
}
static inline uint32 MuscleX86SwapInt32(uint32 val)
{
#ifdef _MSC_VER
__asm {
mov eax, val;
bswap eax;
mov val, eax;
};
#else
__asm__ ("bswap %0" : "+r" (val));
#endif
return val;
}
static inline float MuscleX86SwapFloat(float val)
{
#ifdef _MSC_VER
__asm {
mov eax, val;
bswap eax;
mov val, eax;
};
#else
__asm__ ("bswap %0" : "+r" (val));
#endif
return val;
}
static inline uint64 MuscleX86SwapInt64(uint64 val)
{
#ifdef _MSC_VER
__asm {
mov eax, DWORD PTR val;
mov edx, DWORD PTR val + 4;
bswap eax;
bswap edx;
mov DWORD PTR val, edx;
mov DWORD PTR val + 4, eax;
};
return val;
#else
return ((uint64)(MuscleX86SwapInt32((uint32)((val>>32)&0xFFFFFFFF))))|(((uint64)(MuscleX86SwapInt32((uint32)(val&0xFFFFFFFF))))<<32);
#endif
}
static inline double MuscleX86SwapDouble(double val)
{
#ifdef _MSC_VER
__asm {
mov eax, DWORD PTR val;
mov edx, DWORD PTR val + 4;
bswap eax;
bswap edx;
mov DWORD PTR val, edx;
mov DWORD PTR val + 4, eax;
};
return val;
#else
union {
double _dv;
uint64 _iv;
} u;
u._dv = val;
u._iv = MuscleX86SwapInt64(u._iv);
return u._dv;
#endif
}
# define B_SWAP_DOUBLE(arg) MuscleX86SwapDouble((double)(arg))
# define B_SWAP_FLOAT(arg) MuscleX86SwapFloat((float)(arg))
# define B_SWAP_INT64(arg) MuscleX86SwapInt64((uint64)(arg))
# define B_SWAP_INT32(arg) MuscleX86SwapInt32((uint32)(arg))
# define B_SWAP_INT16(arg) MuscleX86SwapInt16((uint16)(arg))
# else
// No assembly language available... so we'll use inline C
# if defined(__cplusplus)
# define MUSCLE_INLINE inline
# else
# define MUSCLE_INLINE static inline
# endif
MUSCLE_INLINE int64 B_SWAP_INT64(int64 arg)
{
union {int64 _i64; uint8 _i8[8];} u1, u2;
u1._i64 = arg;
u2._i8[0] = u1._i8[7];
u2._i8[1] = u1._i8[6];
u2._i8[2] = u1._i8[5];
u2._i8[3] = u1._i8[4];
u2._i8[4] = u1._i8[3];
u2._i8[5] = u1._i8[2];
u2._i8[6] = u1._i8[1];
u2._i8[7] = u1._i8[0];
return u2._i64;
}
MUSCLE_INLINE int32 B_SWAP_INT32(int32 arg)
{
union {int32 _i32; uint8 _i8[4];} u1, u2;
u1._i32 = arg;
u2._i8[0] = u1._i8[3];
u2._i8[1] = u1._i8[2];
u2._i8[2] = u1._i8[1];
u2._i8[3] = u1._i8[0];
return u2._i32;
}
MUSCLE_INLINE int16 B_SWAP_INT16(int16 arg)
{
union {int16 _i16; uint8 _i8[2];} u1, u2;
u1._i16 = arg;
u2._i8[0] = u1._i8[1];
u2._i8[1] = u1._i8[0];
return u2._i16;
}
MUSCLE_INLINE double B_SWAP_DOUBLE(double arg)
{
union {double _f64; uint8 _i8[8];} u1, u2;
u1._f64 = arg;
u2._i8[0] = u1._i8[7];
u2._i8[1] = u1._i8[6];
u2._i8[2] = u1._i8[5];
u2._i8[3] = u1._i8[4];
u2._i8[4] = u1._i8[3];
u2._i8[5] = u1._i8[2];
u2._i8[6] = u1._i8[1];
u2._i8[7] = u1._i8[0];
return u2._f64;
}
MUSCLE_INLINE float B_SWAP_FLOAT(float arg)
{
union {float _f32; uint8 _i8[4];} u1, u2;
u1._f32 = arg;
u2._i8[0] = u1._i8[3];
u2._i8[1] = u1._i8[2];
u2._i8[2] = u1._i8[1];
u2._i8[3] = u1._i8[0];
return u2._f32;
}
# endif
# if BYTE_ORDER == LITTLE_ENDIAN
# define B_HOST_IS_LENDIAN 1
# define B_HOST_IS_BENDIAN 0
# define B_HOST_TO_LENDIAN_DOUBLE(arg) ((double)(arg))
# define B_HOST_TO_LENDIAN_FLOAT(arg) ((float)(arg))
# define B_HOST_TO_LENDIAN_INT64(arg) ((uint64)(arg))
# define B_HOST_TO_LENDIAN_INT32(arg) ((uint32)(arg))
# define B_HOST_TO_LENDIAN_INT16(arg) ((uint16)(arg))
# define B_HOST_TO_BENDIAN_DOUBLE(arg) B_SWAP_DOUBLE(arg)
# define B_HOST_TO_BENDIAN_FLOAT(arg) B_SWAP_FLOAT(arg)
# define B_HOST_TO_BENDIAN_INT64(arg) B_SWAP_INT64(arg)
# define B_HOST_TO_BENDIAN_INT32(arg) B_SWAP_INT32(arg)
# define B_HOST_TO_BENDIAN_INT16(arg) B_SWAP_INT16(arg)
# define B_LENDIAN_TO_HOST_DOUBLE(arg) ((double)(arg))
# define B_LENDIAN_TO_HOST_FLOAT(arg) ((float)(arg))
# define B_LENDIAN_TO_HOST_INT64(arg) ((uint64)(arg))
# define B_LENDIAN_TO_HOST_INT32(arg) ((uint32)(arg))
# define B_LENDIAN_TO_HOST_INT16(arg) ((uint16)(arg))
# define B_BENDIAN_TO_HOST_DOUBLE(arg) B_SWAP_DOUBLE(arg)
# define B_BENDIAN_TO_HOST_FLOAT(arg) B_SWAP_FLOAT(arg)
# define B_BENDIAN_TO_HOST_INT64(arg) B_SWAP_INT64(arg)
# define B_BENDIAN_TO_HOST_INT32(arg) B_SWAP_INT32(arg)
# define B_BENDIAN_TO_HOST_INT16(arg) B_SWAP_INT16(arg)
# else /* LITTLE_ENDIAN */
# define B_HOST_IS_LENDIAN 0
# define B_HOST_IS_BENDIAN 1
# define B_HOST_TO_LENDIAN_DOUBLE(arg) B_SWAP_DOUBLE(arg)
# define B_HOST_TO_LENDIAN_FLOAT(arg) B_SWAP_FLOAT(arg)
# define B_HOST_TO_LENDIAN_INT64(arg) B_SWAP_INT64(arg)
# define B_HOST_TO_LENDIAN_INT32(arg) B_SWAP_INT32(arg)
# define B_HOST_TO_LENDIAN_INT16(arg) B_SWAP_INT16(arg)
# define B_HOST_TO_BENDIAN_DOUBLE(arg) ((double)(arg))
# define B_HOST_TO_BENDIAN_FLOAT(arg) ((float)(arg))
# define B_HOST_TO_BENDIAN_INT64(arg) ((uint64)(arg))
# define B_HOST_TO_BENDIAN_INT32(arg) ((uint32)(arg))
# define B_HOST_TO_BENDIAN_INT16(arg) ((uint16)(arg))
# define B_LENDIAN_TO_HOST_DOUBLE(arg) B_SWAP_DOUBLE(arg)
# define B_LENDIAN_TO_HOST_FLOAT(arg) B_SWAP_FLOAT(arg)
# define B_LENDIAN_TO_HOST_INT64(arg) B_SWAP_INT64(arg)
# define B_LENDIAN_TO_HOST_INT32(arg) B_SWAP_INT32(arg)
# define B_LENDIAN_TO_HOST_INT16(arg) B_SWAP_INT16(arg)
# define B_BENDIAN_TO_HOST_DOUBLE(arg) ((double)(arg))
# define B_BENDIAN_TO_HOST_FLOAT(arg) ((float)(arg))
# define B_BENDIAN_TO_HOST_INT64(arg) ((uint64)(arg))
# define B_BENDIAN_TO_HOST_INT32(arg) ((uint32)(arg))
# define B_BENDIAN_TO_HOST_INT16(arg) ((uint16)(arg))
# endif /* !LITTLE_ENDIAN */
#endif /* !__BEOS__ */
/* Macro to turn a type code into a string representation.
* (typecode) is the type code to get the string for
* (buf) is a (char *) to hold the output string; it must be >= 5 bytes long.
*/
#define MakePrettyTypeCodeString(typecode, buf) \
{ \
uint32 __bigEndian = B_HOST_TO_BENDIAN_INT32(typecode); \
memcpy(buf, (const char *)&__bigEndian, sizeof(__bigEndian)); \
buf[sizeof(__bigEndian)] = '\0'; \
}
#include <stdio.h>
#include <stdlib.h>
#include <errno.h> /* for errno */
#ifdef WIN32
# include <windows.h>
# include <winsock.h> /* for WSAGetLastError() */
#endif
#ifdef __cplusplus
# include "syslog/SysLog.h" /* for LogTime() */
#endif /* __cplusplus */
/** Checks errno and returns true iff the last I/O operation
* failed because it would have had to block otherwise.
* NOTE: Returns int so that it will compile even in C environments where no bool type is defined.
*/
static inline int PreviousOperationWouldBlock()
{
#ifdef WIN32
return (WSAGetLastError() == WSAEWOULDBLOCK);
#else
return (errno == EWOULDBLOCK);
#endif
}
/** Checks errno and returns true iff the last I/O operation
* failed because it was interrupted by a signal or etc.
* NOTE: Returns int so that it will compile even in C environments where no bool type is defined.
*/
static inline int PreviousOperationWasInterrupted()
{
#ifdef WIN32
return (WSAGetLastError() == WSAEINTR);
#else
return (errno == EINTR);
#endif
}
/** This function applies semi-standard logic to convert the return value
* of a system I/O call and (errno) into a proper MUSCLE-standard return value.
* (A MUSCLE-standard return value's semantics are: Negative on error,
* otherwise the return value is the number of bytes that were transferred)
* @param origRet The return value of the original system call (e.g. to read()/write()/send()/recv())
* @param maxSize The maximum number of bytes that the system call was permitted to send during that call.
* @param blocking True iff the socket/file descriptor is in blocking I/O mode. (Type is int for C compatibility -- it's really a boolean parameter)
* @returns The system call's return value equivalent in MUSCLE return value semantics.
*/
static inline int32 ConvertReturnValueToMuscleSemantics(int origRet, uint32 maxSize, int blocking)
{
int32 retForBlocking = ((origRet > 0)||(maxSize == 0)) ? origRet : -1;
return blocking ? retForBlocking : ((origRet<0)&&((PreviousOperationWouldBlock())||(PreviousOperationWasInterrupted()))) ? 0 : retForBlocking;
}
BEGIN_NAMESPACE(muscle);
#if MUSCLE_TRACE_CHECKPOINTS > 0
/** Exposed as an implementation detail. Please ignore! */
extern volatile uint32 * _muscleTraceValues;
/** Exposed as an implementation detail. Please ignore! */
extern uint32 _muscleNextTraceValueIndex;
/** Sets the location of the trace-checkpoints array to store trace checkpoints into.
* @param location A pointer to an array of at least (MUSCLE_TRACE_CHECKPOINTS) uint32s, or NULL.
* If NULL (or if this function is never called), the default array will be used.
*/
void SetTraceValuesLocation(volatile uint32 * location);
/** Set this process's current trace value to (v). This can be used as a primitive debugging tool, to determine
* where this process was last seen executing -- useful for determining where the process is spinning at.
* @note this function is a no-op if MUSCLE_TRACE_CHECKPOINTS is not defined to a value greater than zero.
*/
static inline void StoreTraceValue(uint32 v)
{
_muscleTraceValues[_muscleNextTraceValueIndex] = v; /* store the current value */
_muscleNextTraceValueIndex = (_muscleNextTraceValueIndex+1)%MUSCLE_TRACE_CHECKPOINTS; /* move the pointer */
_muscleTraceValues[_muscleNextTraceValueIndex] = ((uint32)-1); /* mark the next position with a special tag to show that it's next */
}
/** Returns a pointer to the first value in the trace-values array. */
static inline const volatile uint32 * GetTraceValues() {return _muscleTraceValues;}
/** A macro for automatically setting a trace checkpoint value based on current code location.
* The value will be the two characters of the function or file name, left-shifted by 16 bits,
* and then OR'd together with the current line number. This should give the debugging person a
* fairly good clue as to where the checkpoint was located, while still being very cheap to implement.
*
* @note This function will be a no-op unless MUSCLE_TRACE_CHECKPOINTS is defined to be greater than zero.
*/
#if defined(__GNUC__)
#define TCHECKPOINT \
{ \
const char * d = __FUNCTION__; \
StoreTraceValue((d[0]<<24)|(d[1]<<16)|(__LINE__)); \
}
#else
#define TCHECKPOINT \
{ \
const char * d = __FILE__; \
StoreTraceValue((d[0]<<24)|(d[1]<<16)|(__LINE__)); \
}
#endif
#else
/* no-op implementations for when we aren't using the trace facility */
static inline void SetTraceValuesLocation(volatile uint32 * location) {(void) location;} /* named param is necessary for C compatibility */
static inline void StoreTraceValue(uint32 v) {(void) v;} /* named param is necessary for C compatibility */
#define TCHECKPOINT {/* empty */}
#endif
END_NAMESPACE(muscle);
#endif /* _MUSCLE_SUPPORT_H */
Reference in a new issue View git blame Copy permalink