vlUtil.h

Go to the documentation of this file.

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


#include <iosfwd>

#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

#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)

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 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_ */