---

Utils.h

Go to the documentation of this file.

// ZenLib::ZenUtils - Very small utilities
// Copyright (C) 2002-2003 Jérôme Martinez, Zen@MediaArea.net
//
// This software is provided 'as-is', without any express or implied
// warranty.  In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ZenUtils
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Version 0.1.0
// -------------
// BigEndianToInt    (8-64 bits)
// LittleEndianToInt (8-64 bits)
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// 0.1.0 (Zen@MediaArea.net)
// BigEndianToInt    (8-64 bits)
// LittleEndianToInt (8-64 bits)
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//---------------------------------------------------------------------------
#ifndef ZenUtilsH
#define ZenUtilsH
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
#include <ZenLib/Conf.h>
//---------------------------------------------------------------------------

namespace ZenLib
{

//***************************************************************************
// Integer transformations
//***************************************************************************

//---------------------------------------------------------------------------
//Little Endians
 int8  LittleEndian2int8   (const uint8* List);
uint8  LittleEndian2uint8  (const uint8* List);
 int16 LittleEndian2int16  (const uint8* List);
uint16 LittleEndian2uint16 (const uint8* List);
 int32 LittleEndian2int32  (const uint8* List);
uint32 LittleEndian2uint32 (const uint8* List);
 int64 LittleEndian2int64  (const uint8* List);
uint64 LittleEndian2uint64 (const uint8* List);

//---------------------------------------------------------------------------
//Big Endians
 int8  BigEndian2int8       (const uint8* List);
uint8  BigEndian2uint8      (const uint8* List);
 int16 BigEndian2int16      (const uint8* List);
uint16 BigEndian2uint16     (const uint8* List);
 int32 BigEndian2int32      (const uint8* List);
uint32 BigEndian2uint32     (const uint8* List);
 int64 BigEndian2int64      (const uint8* List);
uint64 BigEndian2uint64     (const uint8* List);

//---------------------------------------------------------------------------
// int32 - int64
#if (MAXTYPES >= 64)
    int64 int32_int64   (                int32 High,  uint32 Low);
    int64 uint32_uint64 (               uint32 High,  uint32 Low);
    void  int64_int32   ( int64 BigInt,  int32 &High, uint32 &Low);
    void  uint64_uint32 (uint64 BigInt, uint32 &High, uint32 &Low);
#endif

//---------------------------------------------------------------------------
// Floats and ints
int32  Float2int32  (float F, int Rounded=1);
uint32 Float2uint32 (float F, int Rounded=1);
int64  Float2int64  (float F, int Rounded=1);
uint64 Float2uint64 (float F, int Rounded=1);

} //namespace ZenLib


/*
#include <list>
#include <stdio.h>


      typedef struct {
              DWORD     address;
              DWORD     size;
              char      file[64];
              DWORD     line;
      } ALLOC_INFO;

      typedef std::list<ALLOC_INFO*> AllocList;

      AllocList *allocList;

      void AddTrack(DWORD addr,  DWORD asize,  const char *fname, DWORD lnum)
      {
              ALLOC_INFO *info;

              if(!allocList) {
                      allocList = new(AllocList);
              }

              info = new(ALLOC_INFO);
              info->address = addr;
              strncpy(info->file, fname, 63);
              info->line = lnum;
              info->size = asize;
              allocList->insert(allocList->begin(), info);
      };

      void RemoveTrack(DWORD addr)
      {
              AllocList::iterator i;

              if(!allocList)
                      return;
              for(i = allocList->begin(); i != allocList->end(); i++)
              {
                      if((*i)->address == addr)
                      {
                              allocList->remove((*i));
                              break;
                      }
              }
      };

      #ifdef _DEBUG
      inline void * __cdecl operator new(unsigned int size,
                                         const char *file, int line)
      {
              void *ptr = (void *)malloc(size);
              AddTrack((DWORD)ptr, size, file, line);
              return(ptr);
      };
      inline void * __cdecl operator new[](unsigned int size,
                                         const char *file, int line)
      {
              void *ptr = (void *)malloc(size);
              AddTrack((DWORD)ptr, size, file, line);
              return(ptr);
      };
      inline void __cdecl operator delete(void *p)
      {
              RemoveTrack((DWORD)p);
              free(p);
      };
      inline void __cdecl operator delete[](void *p)
      {
              RemoveTrack((DWORD)p);
              free(p);
      };
      #define DEBUG_NEW new(__FILE__, __LINE__)
      #else
      #define DEBUG_NEW new
      #endif
      #define new DEBUG_NEW


      void DumpUnfreed()
      {
              AllocList::iterator i;
              DWORD totalSize = 0;

            FILE *stream;
            stream = fopen("d:\\MemoryLeak.txt", "w+");


              if(!allocList)
                      return;

              for(i = allocList->begin(); i != allocList->end(); i++) {
                      fprintf(stream, "%-50s:\t\tLine %d,\t\tAddress %d\t%d unfreed\n",
                              (*i)->file, (*i)->line, (*i)->address, (*i)->size);
                      totalSize += (*i)->size;
              }
              fprintf(stream, "-----------------------------------------------------------\n");
              fprintf(stream, "Total Unfreed: %d bytes\n", totalSize);
      };


*/
#endif

---