/******************************************************** * Some code. Copyright (C) 2003 by Pascal Massimino.   * * All Rights Reserved.      (http://skal.planet-d.net) * * For Educational/Academic use ONLY. See 'LICENSE.TXT'.* ********************************************************//* * skl.h * * Base headers and #def. First file to include. ********************************************************/#ifndef _SKL_H_#define _SKL_H_#include <stdio.h>#include <stdlib.h>#include <stdarg.h>#include <string.h> // for memcpy()...//////////////////////////////////////////////////////////// some global #define//////////////////////////////////////////////////////////////  TODO: should be in some "config.h"#ifdef _WINDOWS#define SKL_EXPORT __declspec(dllexport)#if defined(_MSC_VER) && (_MSC_VER>=1200)#define SKL_MSVC6#else#define SKL_MSVC5#endif#else#define SKL_EXPORT#endif//////////////////////////////////////////////////////////// Some size-controlled types///////////////////////////////////////////////////////////** @file */#ifdef _WINDOWStypedef __int64 SKL_INT64;                /**< type for storing exactly 64bits, signed */typedef unsigned __int64 SKL_UINT64;      /**< type for storing exactly 64bits, unsigned */#elsetypedef long long int SKL_INT64;          /**< type for storing exactly 64bits, signed */typedef unsigned long long int SKL_UINT64;/**< type for storing exactly 64bits, unsigned */#endiftypedef int SKL_INT32;                /**< type for storing exactly 32bits, signed */typedef unsigned int SKL_UINT32;      /**< type for storing exactly 32bits, unsigned */typedef short SKL_INT16;              /**< type for storing exactly 16bits, signed */typedef unsigned short SKL_UINT16;    /**< type for storing exactly 16bits, unsigned */typedef signed char SKL_INT8;         /**< type for storing exactly 8bits, signed */      // <- Irix-cc *requires* 'signed'!typedef unsigned char SKL_UINT8;      /**< type for storing exactly 8bits, unsigned */typedef void *SKL_ANY;                /**< generic pointer type */typedef unsigned char SKL_BYTE;       /**< byte type (8bits, unsigned) */typedef char *SKL_STRING;             /**< generic string type */typedef const char * SKL_CST_STRING;  /**< generic constant string type */#ifdef SKL_64BITStypedef SKL_UINT64 SKL_SAFE_INT;      /**< generic integer type capable of safely storing 64bits or 32bits pointers (depending on the platform) */#elsetypedef SKL_UINT32 SKL_SAFE_INT;      /**< generic integer type capable of safely storing 64bits or 32bits pointers (depending on the platform) */#endif//////////////////////////////////////////////////////////// Debug utilities//////////////////////////////////////////////////////////#define SKL_NYI abort()#if 0 //#ifdef __ANSI_CPP__#define SKL_MK_STRING(x)  "x"#else#define SKL_MK_STRING(x)  #x#endif  /** When NDEBUG is _not_ defined (debug mode, e.g.), a       faulty SKL_ASSERT( condition ) will call this function.      Its main purpose is for you to be able to put       a breakpoint with a debugger (beside ensuring      that no assert is violated, of course).   */extern void Skl_Do_Assert(SKL_CST_STRING Condition,                           SKL_CST_STRING File,                           int Line,                          SKL_CST_STRING Msg);#ifndef NDEBUG  /** Replacement for assert(), calling Skl_Do_Assert() */#define SKL_ASSERT(EX)                                \  ((void) ((EX) ||                                    \   (Skl_Do_Assert( (SKL_CST_STRING)SKL_MK_STRING(EX), \                   (SKL_CST_STRING)__FILE__, (int)__LINE__, 0), 0)))#else  /** Replacement for assert(), calling Skl_Do_Assert() */#define SKL_ASSERT(a) ((void)0)#endif//////////////////////////////////////////////////////////// Exceptions forward dcl (cf. skl_syst/skl_exception.h)//////////////////////////////////////////////////////////class SKL_EXCEPTION {  protected:    enum { MAX_LEN=2048 };  public:    static char _Msg[MAX_LEN];  public:    SKL_EXCEPTION(SKL_CST_STRING Msg=0);    virtual ~SKL_EXCEPTION() {}    virtual void Print() const;  	static SKL_CST_STRING Get_Message() { return _Msg; }};//////////////////////////////////////////////////////////// -- Memory managment interface// Default implementation uses malloc() / free()//////////////////////////////////////////////////////////  /** Instance of this class should provide interface for memory allocation      and disallocation. The default implementation uses malloc() / free()      low-level calls.<br>      A new-with-placement operator is defined, taking the memory pool      as placement data. You can then use: new (Mem) MY_CLASS to allocate      MY_CLASS on the SKL_MEM_I *Mem memory pool. <br>      For convenience, a default global static instance of SKL_MEM_I      is available as: SKL_MEM_I *SKL_MEM.<br>    */class SKL_MEM_I{  public:    SKL_MEM_I();    virtual ~SKL_MEM_I();      /** This function should return a pointer to a freshly allocation          memory segment of at least 'Size' size. It returns 0          if allocation was not possible.          @param Size the desired size to be allocated.        */    virtual SKL_ANY New(const size_t Size);      /** This function should disallocate the memory segment pointed to          by the 'p' parameter, and of size 'Size'.          @param p Pointer to the memory segment. This pointer should have          been obtained by a call to New() member function.          @param Size size of the memory to be freed. This size *must* match          the size that was passed to the corresponding New() call as argument.        */    virtual void Delete(const SKL_ANY p, size_t Size);      /** This function re-allocates, without copying its content, a memory          segment of size 'Old_Size' referenced by 'Ptr'. The new size is          passed a 'Size' argument.        */    void Realloc(SKL_ANY &Ptr,                   const size_t Size,         // if Old_Size>0 -> "Grow" to Size                  const size_t Old_Size=0 ); // else "Shrink" to Size};extern SKL_MEM_I * const SKL_MEM;//////////////////////////////////////////////////////////// New/Delete operators (what a mess!)//////////////////////////////////////////////////////////  /** Overloaded new-with-placement operator, using SKL_MEM_I.      @see SKL_MEM_I */inline void *operator new (size_t s, SKL_MEM_I *m) {   if (!s) return (void*)s;  // wow!   (this avoids some warning msg)  if (m==0) return malloc(s);  return m->New(s); }#if !defined(SKL_MSVC5)inline void *operator new[] (size_t s, SKL_MEM_I *m) {  if (!s) return (void*)s;  // re-wow!  if (m==0) return malloc(s);  return m->New(s); }#if defined(SKL_MSVC6)  // Hmm... There seems to be a bug => I *must*   // redefine a '::new []' whenever I define a 'new (Mem) []'inline void *operator new[] (size_t s) {  if (!s) return (void*)s;  // re-wow!  return malloc(s);}inline void operator delete(void *Ptr) { if (Ptr) free(Ptr); }inline void operator delete [] (void *Ptr) { if (Ptr) free(Ptr); }#endif#endif#if defined(SKL_MSVC6)inline void operator delete(void *Ptr, SKL_MEM_I *m) {}#define SKL_DEL_OP(T) \public:               \ /* inline void operator delete(void *Ptr, SKL_MEM_I *m) {} */\private:#else#define SKL_DEL_OP(T) #endif//////////////////////////////////////////////////////////// System dependant useful macros//////////////////////////////////////////////////////////  // system dependant...#define SKL_MEMMOVE(dst,src,size) memmove((void*)(dst),(void*)(src),(size_t)(size))#define SKL_MEMCPY(dst,src,size) memcpy((void*)(dst),(void*)(src),(size_t)(size))#define SKL_BZERO(ptr,size) memset((void*)(ptr),0,(size_t)(size))#define SKL_MEMSET(ptr,c,size) memset((void*)(ptr),(unsigned char)(c),(size_t)(size))//////////////////////////////////////////////////////////#endif   /* _SKL_H_ */