vlUtil.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1992-2010 MAK Technologies, Inc
** All rights reserved.
*******************************************************************************/
#ifndef _vlutil_H_
#define _vlutil_H_



// Check compiler flags
#ifdef _WIN32
#if _MSC_VER == 1400 //VC8
#if _SECURE_SCL != 0 || _HAS_ITERATOR_DEBUGGING != 0
#error Compiler Flags do not match!  Do not use _SECURE_SCL or _HAS_ITERATOR_DEBUGGING
#endif // _SECURE_SCL != 0 || _HAS_ITERATOR_DEBUGGING != 0
#endif //_MSC_VER == 1400
#endif //_WIN32

#include <iosfwd>
#include <iostream>
#include <sstream>
#include <bitset>

#ifndef VLCONFIG_INCLUDED_H_
#include "vlConfig.h"
#endif

#if VXWORKS
#include <string.h>
extern "C"
{
#include <unistd.h>
}
#endif

#ifdef _WIN32
  #include <winsock2.h>
  #include <ws2tcpip.h>
#endif

#if DT_HAVE_UNISTD_H
#include <unistd.h> 
#endif  

#ifdef PCFTP
#include <4bsddefs.h>
#endif
  
extern "C" {  
#include <stdlib.h>
#include <sys/types.h>
}

#include "vlTime.h"
#include "math.h"

#if DT_FD_ZERO_USES_MEMSET
#include <string.h>
#else 

#if DT_HAVE_BZERO_PROTO_IN_MEMORY_H
#include <memory.h>
#elif DT_HAVE_BZERO_PROTO_IN_CC_LIBC_H
#include <CC/libc.h>
#elif DT_HAVE_BZERO_PROTO_IN_BSTRING_H
#include <bstring.h>
#else
extern "C"
{  
   void bzero( char* b, int length ); 
}
#endif

#endif 

#if __SUNPRO_CC
#include <sys/file.h>
#endif

#ifdef VMS
#include <time.h>
#endif
#include <vector>

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

#define DtDELETE(x) \
   if (x) \
   { \
      delete x; \
      x = NULL; \
   }

#define DtDELETE_VOID(x, cast) \
   if (x) \
   { \
      cast* toDelete = reinterpret_cast<cast*>(x); \
      delete toDelete; \
      x = 0; \
   }


#ifndef DtISON
#define DtISON(a, x) (a & x)
#define DtISOFF(a, x) (!DtISON(a, x))
#define DtTURNON(a, x) (a |= x)
#define DtTURNOFF(a, x) (a &= ~x)
#endif


#define DtNUMBER(foo) (sizeof(foo)/sizeof(foo[0]))
#define DtOFFSET(type, field) ((size_t)&((type *)NULL)->field)
#define DtSIZEOF(type, field) sizeof(((type *)NULL)->field)

#define DtRGBA_TO_UINT(r, g, b, a)   ((((a) << 24) | ((r) << 16) | ((g) << 8) | (b)))

DT_DLL_VLUTIL inline void DtUINT_TO_RGBA(unsigned int val, unsigned int& r, unsigned int& g, unsigned int& b, unsigned int& a)
{
   a = (unsigned char)(val >> 24) & 0xFF;
   r = (unsigned char)(val >> 16) & 0xFF;
   g = (unsigned char)(val >> 8) & 0xFF;
   b = (unsigned char)(val) & 0xFF;
}

class DtString;


inline int DtROUND_TO_MULT( int num, int mult )
{
   return (int)ceil( (float)num / (float)mult ) * mult;
}


#if DT_HAVE_STRTOUL
#define DtATOI(s)  ((int)(strtoul(s, 0, 0)))
#else
#define DtATOI(s)  (int)strtol(s, 0, 0)
#endif

template<typename T>
T DtMax(T x,T y)
{
   return (x>y ? x:y);
}

template<typename T>
T DtMin(T x,T y)
{
   return (x<y ? x:y);
}

DT_DLL_VLUTIL char* DtDeg2DmsString( double val, char* buff, int prec );

#if !VMS
DT_DLL_VLUTIL char* DtDeg2DmsString( double val );
#endif

DT_DLL_VLUTIL DtString DtHexToBinary(const std::string& s, int sLength = 0);

DT_DLL_VLUTIL DtString DtBinaryToHex(const std::string& s);

DT_DLL_VLUTIL void DtDecimalToBinary(const DtU32 value, std::vector<int>& binVal);

DT_DLL_VLUTIL int DtBinaryToDecimal(const std::string& s);

#define DT_8_BIT_MASK(value, bit) (DtU8)((value & ((DtU8)1 << bit)) >>bit)

#define DT_SET_8_BIT_MASK(value, bit) (value | ((DtU8)1 << bit) )

#define DT_8_BITS_MASK(value, yBits, startBit) (DtU8)((value & ((((DtU8)1 << yBits) -1) <<startBit)) >> startBit )

#define DT_16_BIT_MASK(value, bit) (DtU16)((value & ((DtU16)1 << bit)) >> bit)

#define DT_SET_16_BIT_MASK(value, bit) (value | ((DtU16)1 << bit) )

#define DT_16_BITS_MASK(value, yBits, startBit) (DtU16)((value & ((((DtU16)1 << yBits) -1) <<startBit)) >> startBit )

#define DT_32_BIT_MASK(value, bit) (DtU32)((value & ((DtU32)1 << bit)) >> bit)

#define DT_SET_32_BIT_MASK(value, bit) (value | ((DtU32)1 << bit) )

DT_DLL_VLUTIL int DtIsInList( const int* lst, int num );



DT_DLL_VLUTIL int DtSelect( int n, fd_set* i, fd_set* o, fd_set* e, DtTime t );

#ifdef _WIN32
DT_DLL_VLUTIL inline void DtClose( int &fd )
{
   if ( fd >= 0 ) closesocket( fd );
   fd = -1;
}
#else
DT_DLL_VLUTIL inline void DtClose( int &fd )
{
   if ( fd >= 0 ) close( fd );
   fd = -1;
}
#endif


class DT_DLL_VLUTIL DtSelectParam 
{
public:
   DtSelectParam()
   {
      FD_ZERO( &read0 );
      read = read0;
      maxfd = -1;
   }
   int select(DtTime timeout)
   {
      read = read0;
      return DtSelect( maxfd+1, &read, NULL, NULL, timeout );
   }
   void addRead( int fd )
   {
      FD_SET( (unsigned int)fd, &read0 );
      maxfd = DtMax( maxfd, fd );
   }
   void delRead( int fd )
   {
      FD_CLR( (unsigned int)fd, &read0 );
   }
   int canRead( int fd )
   {
      return ( (int)( FD_ISSET( (unsigned int)fd, &read ) ) );
   }

private:
   int maxfd;
   fd_set read0;
   fd_set read;
};

DT_DLL_VLUTIL char* DtStrdup( const char* str );

DT_DLL_VLUTIL char* DtToLower( char* str );

DT_DLL_VLUTIL char* DtToUpper( char* str );

/* ---------------------- inet utils ---------------------- */

typedef DtU32 DtIpv4Addr;

const DtIpv4Addr DtInetAddrAny = 0;

const DtIpv4Addr loopbackAddr = 0x7f000001;  /* 127.0.0.1 */

DT_DLL_VLUTIL const char* DtInetAddrString( DtIpv4Addr addr );

#if _PowerUX
DT_DLL_VLUTIL DtIpv4Addr DtStringToInetAddr( char* str );
#else
DT_DLL_VLUTIL DtIpv4Addr DtStringToInetAddr( const char* str );
#endif

DT_DLL_VLUTIL DtIpv4Addr DtStringToInetAddr(const DtString& str );

#if _PowerUX
DT_DLL_VLUTIL DtIpv4Addr DtHexStringToInetAddr( char* str );
#else
DT_DLL_VLUTIL DtIpv4Addr DtHexStringToInetAddr( const char* str );
#endif


inline DtMachineSize alignValue(DtMachineSize value, DtMachineSize alignment)
{
   DtMachineSize alignMask = ~alignment+1;  // Two's compliment

   // No need to align for alignment of 1 or less
   if (alignment > 1 && value != (value&alignMask))
   {
      // The value is not aligned
      // Extend the value past the next alignment.
      // Then use bitwise "and" operation with the 2's compliment of the alignment size
      // to take out extra bits (if any) that were added in past the alignment.
      value += alignment;
      value &= alignMask;
   }
   return value;
}

inline const void* alignPtr(const void* ptr, DtMachineSize alignment)
{
   DtMachineSize value = reinterpret_cast<DtMachineSize>(ptr);
   return reinterpret_cast<void*>(alignValue(value, alignment));
}
inline void* alignPtr(void* ptr, DtMachineSize alignment)
{
   DtMachineSize value = reinterpret_cast<DtMachineSize>(ptr);
   return reinterpret_cast<void*>(alignValue(value, alignment));
}

inline DtMachineSize alignedPadding(DtMachineSize value, DtMachineSize alignment)
{
   DtMachineSize padding = 0;
   if (alignment > 1)
   {
      // Not quite sure of the logic of this operation but it works.
      padding  = (~value)+1;
      padding  &= (alignment-1);
   }

   return padding;
}

inline DtMachineSize alignedPtrPadding(const void* ptr, DtMachineSize alignment)
{
   DtMachineSize value = reinterpret_cast<DtMachineSize>(ptr);
   return alignedPadding(value, alignment);
}


#if DT_NO_STRDUP
DT_DLL_VLUTIL char* strdup( const char* str );
#endif
#if DT_NO_CASECOMPARE
DT_DLL_VLUTIL int strcasecmp( const char* strA, const char* strB );
#endif
DT_DLL_VLUTIL int DtResizeString( char*& buf, int& oldLn, int newLn );

DT_DLL_VLUTIL int DtArgc( char* cmdLine );
DT_DLL_VLUTIL char** DtArgv( char* cmdLine, int* argc = NULL );

DT_DLL_VLUTIL const char* DtOperatingSystem();

DT_DLL_VLUTIL const char* DtCompiler();

DT_DLL_VLUTIL int DtGetPid();

DT_DLL_VLUTIL int DtGetPPid();

#define DT_VXWORKS_APP(name) \
int main(int argc, char** argv); \
int name(char* cmdLine) \
{ \
   return realMain(DtArgc(cmdLine), DtArgv(cmdLine)); \
}

DT_DLL_VLUTIL void printHexToStream( std::ostream& stream, unsigned int numberOfColumns,
   unsigned char * ptr, unsigned int bytes );


#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif


#endif   /* _VLUTIL_H_ */