Crystal Space: cssysdef.h Source File (Crystal Space Public API Reference)

| ## Public API Reference

- Main Page
- Modules
- Namespaces
- Classes
- Files
- Related Pages

- File List
- File Members

# cssysdef.h

Go to the documentation of this file.

    00001 /*
    00002     Copyright (C) 1998-2001 by Jorrit Tyberghein
    00003     Written by Andrew Zabolotny <bit@eltech.ru>
    00004
    00005     This library is free software; you can redistribute it and/or
    00006     modify it under the terms of the GNU Library General Public
    00007     License as published by the Free Software Foundation; either
    00008     version 2 of the License, or (at your option) any later version.
    00009
    00010     This library is distributed in the hope that it will be useful,
    00011     but WITHOUT ANY WARRANTY; without even the implied warranty of
    00012     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00013     Library General Public License for more details.
    00014
    00015     You should have received a copy of the GNU Library General Public
    00016     License along with this library; if not, write to the Free
    00017     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    00018 */
    00019
    00020 #ifndef __CS_CSSYSDEF_H__
    00021 #define __CS_CSSYSDEF_H__
    00022
    00023 #define CSDEF_FRIEND
    00024 #include "csdef.h"
    00025 #undef CSDEF_FRIEND
    00026
    00036 /*
    00037  * Pull in platform-specific overrides of the requested functionality.
    00038  */
    00039 #include "csutil/csosdefs.h"
    00040
    00041 // Defaults for platforms that do not define their own.
    00042 #ifndef CS_VISIBILITY_DEFAULT
    00043 #  define CS_VISIBILITY_DEFAULT
    00044 #endif
    00045 #ifndef CS_VISIBILITY_HIDDEN
    00046 #  define CS_VISIBILITY_HIDDEN
    00047 #endif
    00048 #ifndef CS_EXPORT_SYM_DLL
    00049 #  define CS_EXPORT_SYM_DLL CS_VISIBILITY_DEFAULT
    00050 #endif
    00051 #ifndef CS_IMPORT_SYM_DLL
    00052 #  define CS_IMPORT_SYM_DLL extern
    00053 #endif
    00054 #ifndef CS_EXPORT_SYM
    00055 #  if defined(CS_BUILD_SHARED_LIBS)
    00056 #    define CS_EXPORT_SYM CS_VISIBILITY_DEFAULT
    00057 #  else
    00058 #    define CS_EXPORT_SYM
    00059 #  endif
    00060 #endif
    00061 #ifndef CS_IMPORT_SYM
    00062 #  define CS_IMPORT_SYM
    00063 #endif
    00064
    00065 #include "csextern.h"
    00066
    00067 /*
    00068  * Default definitions for requested functionality.  Platform-specific
    00069  * configuration files may override these.
    00070  */
    00071
    00072 #ifndef CS_FORCEINLINE
    00073 # ifdef CS_COMPILER_GCC
    00074 #  define CS_FORCEINLINE inline __attribute__((always_inline))
    00075 #  if (__GNUC__ == 3) && (__GNUC_MINOR__ == 4)
    00076     // Work around a gcc 3.4 issue where forcing inline doesn't always work
    00077 #   define CS_FORCEINLINE_TEMPLATEMETHOD inline
    00078 #  endif
    00079 # else
    00080 #  define CS_FORCEINLINE inline
    00081 # endif
    00082 #endif
    00083 #ifndef CS_FORCEINLINE_TEMPLATEMETHOD
    00084 # define CS_FORCEINLINE_TEMPLATEMETHOD CS_FORCEINLINE
    00085 #endif
    00086
    00091 #if defined(CS_COMPILER_MSVC)
    00092   #include <exception>
    00093   #if !_HAS_EXCEPTIONS
    00094     #define CS_NO_EXCEPTIONS
    00095   #endif
    00096 #elif defined(CS_COMPILER_GCC) && !defined(__EXCEPTIONS)
    00097   #define CS_NO_EXCEPTIONS
    00098 #endif
    00099
    00104 #ifndef CS_MAXPATHLEN
    00105 #define CS_MAXPATHLEN 1024
    00106 #endif
    00107 #include <stdio.h>
    00108 #ifdef CS_HAVE_SYS_PARAM_H
    00109 #include <sys/param.h>
    00110 #endif
    00111
    00118 #if defined(CS_COMPILER_GCC) && !defined(__STRICT_ANSI__)
    00119 // In GCC we are able to declare stack vars of dynamic size directly
    00120 #  define CS_ALLOC_STACK_ARRAY(type, var, size) \
    00121      type var [size]
    00122 #else
    00123 #  include <stdlib.h>
    00124 #  define CS_ALLOC_STACK_ARRAY(type, var, size) \
    00125      type *var = (type *)alloca ((size) * sizeof (type))
    00126 #  if defined(CS_COMPILER_GCC) && defined(__STRICT_ANSI__) && !defined(alloca)
    00127 #    define alloca(x) __builtin_alloca(x)
    00128 #  endif
    00129 #endif
    00130
    00134 #ifndef CS_TEMP_DIR
    00135 #  if defined(CS_PLATFORM_UNIX)
    00136 #    define CS_TEMP_DIR "/tmp/"
    00137 #  else
    00138 #    define CS_TEMP_DIR ""
    00139 #  endif
    00140 #endif
    00141
    00145 #ifndef CS_TEMP_FILE
    00146 #  if defined(CS_PLATFORM_UNIX)
    00147 #    define CS_TEMP_FILE "cs%lud.tmp", (unsigned long)getpid()
    00148 #  else
    00149 #    define CS_TEMP_FILE "$cs$.tmp"
    00150 #  endif
    00151 #endif
    00152
    00176 #define CS_HEADER_GLOBAL(X,Y) CS_HEADER_GLOBAL_COMPOSE(X,Y)
    00177 #define CS_HEADER_GLOBAL_COMPOSE(X,Y) <X/Y>
    00178
    00191 #define CS_HEADER_LOCAL(X,Y) CS_HEADER_LOCAL_COMPOSE1(X,Y)
    00192 #define CS_HEADER_LOCAL_COMPOSE1(X,Y) CS_HEADER_LOCAL_COMPOSE2(X/Y)
    00193 #define CS_HEADER_LOCAL_COMPOSE2(X) #X
    00194
    00195
    00201 #if !defined(CS_EXPORTED_FUNCTION)
    00202 #  if defined(CS_STATIC_LINKED)
    00203 #    define CS_EXPORTED_FUNCTION extern "C"
    00204 #  else
    00205 #    define CS_EXPORTED_FUNCTION extern "C" CS_EXPORT_SYM_DLL
    00206 #  endif
    00207 #endif
    00208
    00220 #if !defined(CS_EXPORTED_NAME)
    00221 #  define CS_EXPORTED_NAME(Prefix, Suffix) Prefix ## Suffix
    00222 #endif
    00223
    00224 #ifndef CS_IMPLEMENT_PLATFORM_PLUGIN
    00225 #  define CS_IMPLEMENT_PLATFORM_PLUGIN
    00226 #endif
    00227
    00228 #ifndef CS_IMPLEMENT_PLATFORM_APPLICATION
    00229 #  define CS_IMPLEMENT_PLATFORM_APPLICATION
    00230 #endif
    00231
    00238 #ifndef CS_INITIALIZE_PLATFORM_APPLICATION
    00239 #  define CS_INITIALIZE_PLATFORM_APPLICATION /* */
    00240 /*
    00241   This definition may seem odd, but it's here for doxygen's sake, which
    00242   apparently fails to document empty macro definitions.
    00243  */
    00244 #endif
    00245
    00246 typedef void (*csStaticVarCleanupFN) (void (*p)());
    00247 extern csStaticVarCleanupFN csStaticVarCleanup;
    00248
    00249 #ifndef CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION
    00250 #  define CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION(Name)              \
    00251 void Name (void (*p)())                                                \
    00252 {                                                                      \
    00253   static void (**a)() = 0;                                             \
    00254   static int lastEntry = 0;                                            \
    00255   static int maxEntries = 0;                                           \
    00256                                                                        \
    00257   if (p != 0)                                                          \
    00258   {                                                                    \
    00259     if (lastEntry >= maxEntries)                                       \
    00260     {                                                                  \
    00261       maxEntries += 10;                                                \
    00262       if (a == 0)                                                      \
    00263         a = (void (**)())malloc(maxEntries * sizeof(void*));           \
    00264       else                                                             \
    00265         a = (void (**)())realloc(a, maxEntries * sizeof(void*));       \
    00266     }                                                                  \
    00267     a[lastEntry++] = p;                                                \
    00268   }                                                                    \
    00269   else if (a != 0)                                                     \
    00270   {                                                                    \
    00271     for (int i = lastEntry - 1; i >= 0; i--)                           \
    00272       a[i] ();                                                         \
    00273     free (a);                                                          \
    00274     a = 0;                                                             \
    00275     lastEntry = 0;                                                     \
    00276     maxEntries = 0;                                                    \
    00277   }                                                                    \
    00278 }
    00279 #endif
    00280
    00281 #ifndef CS_DEFINE_STATIC_VARIABLE_REGISTRATION
    00282 #  define CS_DEFINE_STATIC_VARIABLE_REGISTRATION(func) \
    00283     csStaticVarCleanupFN csStaticVarCleanup = &func
    00284 #endif
    00285
    00286 #ifndef CS_DECLARE_STATIC_VARIABLE_REGISTRATION
    00287 #  define CS_DECLARE_STATIC_VARIABLE_REGISTRATION(func) \
    00288     void func (void (*p)())
    00289 #endif
    00290
    00291 #ifndef CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION
    00292 #  define CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION               \
    00293     CS_CRYSTALSPACE_EXPORT                                              \
    00294     CS_DECLARE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);
    00295 #endif
    00296
    00297 /* scfStaticallyLinked - Flag indicating whether external linkage was used when
    00298  * building the application. Determines whether SCF scans for plugins at
    00299  * startup.
    00300  */
    00304 #if defined(CS_BUILD_SHARED_LIBS)
    00305 #  define CS_DEFINE_STATICALLY_LINKED_FLAG
    00306 #elif defined(CS_STATIC_LINKED)
    00307 #  define CS_DEFINE_STATICALLY_LINKED_FLAG  bool scfStaticallyLinked = true;
    00308 #else
    00309 #  define CS_DEFINE_STATICALLY_LINKED_FLAG  bool scfStaticallyLinked = false;
    00310 #endif
    00311
    00312
    00332 #ifndef CS_IMPLEMENT_FOREIGN_DLL
    00333 #  if defined(CS_BUILD_SHARED_LIBS)
    00334 #    define CS_IMPLEMENT_FOREIGN_DLL                                        \
    00335        CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION(csStaticVarCleanup_local); \
    00336        CS_DEFINE_STATICALLY_LINKED_FLAG                                     \
    00337        CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_local);
    00338 #  else
    00339 #    define CS_IMPLEMENT_FOREIGN_DLL                                        \
    00340        CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION                      \
    00341        CS_DEFINE_STATICALLY_LINKED_FLAG                                     \
    00342        CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);
    00343 #  endif
    00344 #endif
    00345
    00354 #if defined(CS_STATIC_LINKED)
    00355
    00356 #  ifndef CS_IMPLEMENT_PLUGIN
    00357 #  define CS_IMPLEMENT_PLUGIN                                           \
    00358           CS_IMPLEMENT_PLATFORM_PLUGIN
    00359 #  endif
    00360
    00361 #elif !defined(CS_BUILD_SHARED_LIBS)
    00362
    00363 #  ifndef CS_IMPLEMENT_PLUGIN
    00364 #  define CS_IMPLEMENT_PLUGIN                                           \
    00365           CS_IMPLEMENT_PLATFORM_PLUGIN                                  \
    00366           CS_DEFINE_STATICALLY_LINKED_FLAG                              \
    00367           CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION               \
    00368           CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);
    00369 #  endif
    00370
    00371 #else
    00372
    00373 #  ifndef CS_IMPLEMENT_PLUGIN
    00374 #  define CS_IMPLEMENT_PLUGIN                                           \
    00375    CS_DEFINE_STATICALLY_LINKED_FLAG                                     \
    00376    CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION(csStaticVarCleanup_local)  \
    00377    CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_local);   \
    00378    CS_IMPLEMENT_PLATFORM_PLUGIN
    00379 #  endif
    00380
    00381 #endif
    00382
    00391 #ifndef CS_IMPLEMENT_APPLICATION
    00392 #  define CS_IMPLEMENT_APPLICATION                                      \
    00393   CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION                       \
    00394   CS_DEFINE_STATICALLY_LINKED_FLAG                                      \
    00395   CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);   \
    00396   CS_IMPLEMENT_PLATFORM_APPLICATION
    00397 #endif
    00398
    00402 #ifndef CS_REGISTER_STATIC_FOR_DESTRUCTION
    00403 #define CS_REGISTER_STATIC_FOR_DESTRUCTION(getterFunc)\
    00404         csStaticVarCleanup (getterFunc);
    00405 #endif
    00406
    00410 #ifndef CS_STATIC_VARIABLE_CLEANUP
    00411 #define CS_STATIC_VARIABLE_CLEANUP  \
    00412         csStaticVarCleanup (0);
    00413 #endif
    00414
    00427 #ifndef CS_IMPLEMENT_STATIC_VAR_EXT
    00428 #define CS_IMPLEMENT_STATIC_VAR_EXT(getterFunc,Type,initParam,kill_how) \
    00429 namespace {                                                            \
    00430 static Type *getterFunc ## _v=0;                                        \
    00431 static Type* getterFunc ();                                             \
    00432 static void getterFunc ## _kill ();                                     \
    00433 static void getterFunc ## _kill_array ();                               \
    00434 void getterFunc ## _kill ()                                             \
    00435 {                                                                       \
    00436   (void)(&getterFunc ## _kill_array);                                   \
    00437   delete getterFunc ## _v;                                              \
    00438   getterFunc ## _v = 0;                                                 \
    00439 }                                                                       \
    00440 void getterFunc ## _kill_array ()                                       \
    00441 {                                                                       \
    00442   (void)(&getterFunc ## _kill);                                         \
    00443   delete [] getterFunc ## _v;                                           \
    00444   getterFunc ## _v = 0;                                                 \
    00445 }                                                                       \
    00446 Type* getterFunc ()                                                     \
    00447 {                                                                       \
    00448   if (!getterFunc ## _v)                                                \
    00449   {                                                                     \
    00450     getterFunc ## _v = new Type initParam;                              \
    00451     csStaticVarCleanup (getterFunc ## kill_how);                        \
    00452   }                                                                     \
    00453   return getterFunc ## _v;                                              \
    00454 }                                                                       \
    00455 }
    00456 #endif
    00457
    00458 #ifndef CS_IMPLEMENT_STATIC_VAR
    00459 #define CS_IMPLEMENT_STATIC_VAR(getterFunc,Type,initParam) \
    00460  CS_IMPLEMENT_STATIC_VAR_EXT(getterFunc,Type,initParam,_kill)
    00461 #endif
    00462
    00463 #ifndef CS_IMPLEMENT_STATIC_VAR_ARRAY
    00464 #define CS_IMPLEMENT_STATIC_VAR_ARRAY(getterFunc,Type,initParam) \
    00465  CS_IMPLEMENT_STATIC_VAR_EXT(getterFunc,Type,initParam,_kill_array)
    00466 #endif
    00467
    00475 #ifndef CS_DECLARE_STATIC_CLASSVAR
    00476 #define CS_DECLARE_STATIC_CLASSVAR(var,getterFunc,Type)       \
    00477 static Type *var;                                             \
    00478 static Type *getterFunc ();                                   \
    00479 static void getterFunc ## _kill ();                           \
    00480 static void getterFunc ## _kill_array ();
    00481 #endif
    00482
    00483 #ifndef CS_DECLARE_STATIC_CLASSVAR_REF
    00484 #define CS_DECLARE_STATIC_CLASSVAR_REF(var,getterFunc,Type)   \
    00485 static Type *var;                                             \
    00486 static Type &getterFunc ();                                   \
    00487 static void getterFunc ## _kill ();                           \
    00488 static void getterFunc ## _kill_array ();
    00489 #endif
    00490
    00501 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_EXT
    00502 #define CS_IMPLEMENT_STATIC_CLASSVAR_EXT(Class,var,getterFunc,Type,initParam,\
    00503   kill_how)                                                     \
    00504 Type *Class::var = 0;                                           \
    00505 void Class::getterFunc ## _kill ()                              \
    00506 {                                                               \
    00507   delete getterFunc ();                                         \
    00508   var = 0;                                                      \
    00509 }                                                               \
    00510 void Class::getterFunc ## _kill_array ()                        \
    00511 {                                                               \
    00512   delete [] getterFunc ();                                      \
    00513   var = 0;                                                      \
    00514 }                                                               \
    00515 Type* Class::getterFunc ()                                      \
    00516 {                                                               \
    00517   if (!var)                                                     \
    00518   {                                                             \
    00519     var = new Type initParam;                                   \
    00520     csStaticVarCleanup (getterFunc ## kill_how);                \
    00521   }                                                             \
    00522   return var;                                                   \
    00523 }
    00524 #endif
    00525
    00526 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR
    00527 #define CS_IMPLEMENT_STATIC_CLASSVAR(Class,var,getterFunc,Type,initParam) \
    00528   CS_IMPLEMENT_STATIC_CLASSVAR_EXT(Class,var,getterFunc,Type,initParam,_kill)
    00529 #endif
    00530
    00531 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_ARRAY
    00532 #define CS_IMPLEMENT_STATIC_CLASSVAR_ARRAY(Class,var,getterFunc,Type,\
    00533   initParam) \
    00534   CS_IMPLEMENT_STATIC_CLASSVAR_EXT(Class,var,getterFunc,Type,initParam,\
    00535     _kill_array)
    00536 #endif
    00537
    00538 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT
    00539 #define CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT(Class,var,getterFunc,Type,\
    00540   initParam,kill_how) \
    00541 Type *Class::var = 0;                                          \
    00542 void Class::getterFunc ## _kill ()                             \
    00543 {                                                              \
    00544   delete &getterFunc ();                                       \
    00545   var = 0;                                                     \
    00546 }                                                              \
    00547   void Class::getterFunc ## _kill_array ()                     \
    00548 {                                                              \
    00549   delete [] &getterFunc ();                                    \
    00550   var = 0;                                                     \
    00551 }                                                              \
    00552 Type &Class::getterFunc ()                                     \
    00553 {                                                              \
    00554   if (!var)                                                    \
    00555   {                                                            \
    00556     var = new Type initParam;                                  \
    00557     csStaticVarCleanup (getterFunc ## kill_how);               \
    00558   }                                                            \
    00559   return *var;                                                 \
    00560 }
    00561 #endif
    00562
    00563 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_REF
    00564 #define CS_IMPLEMENT_STATIC_CLASSVAR_REF(Class,var,getterFunc,Type,initParam)\
    00565   CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT(Class,var,getterFunc,Type,\
    00566     initParam,_kill)
    00567 #endif
    00568
    00569 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_REF_ARRAY
    00570 #define CS_IMPLEMENT_STATIC_CLASSVAR_REF_ARRAY(Class,var,getterFunc,Type,\
    00571   initParam) \
    00572   CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT(Class,var,getterFunc,Type,initParam,\
    00573     _kill_array)
    00574 #endif
    00575
    00580 #if defined(CS_COMPILER_GCC)
    00581 #  define CS_FUNCTION_NAME              __PRETTY_FUNCTION__
    00582 #elif defined(__FUNCTION__)
    00583 #  define CS_FUNCTION_NAME              __FUNCTION__
    00584 #else
    00585 #  define CS_FUNCTION_NAME              "<?\?\?>"
    00586 #endif
    00587
    00588 /* Include now, if it's included later, the malloc re#definition below may
    00589  * interfere with that header. */
    00590 #include <stdlib.h>
    00591 #ifdef CS_HAVE_MALLOC_H
    00592 #include <malloc.h>
    00593 #endif
    00594 #include <new>
    00595
    00602 CS_FORCEINLINE void* platform_malloc (size_t n)
    00603 { return malloc (n); }
    00604 CS_FORCEINLINE void platform_free (void* p)
    00605 { return free (p); }
    00606 CS_FORCEINLINE void* platform_realloc (void* p, size_t n)
    00607 { return realloc (p, n); }
    00608 CS_FORCEINLINE void* platform_calloc (size_t n, size_t s)
    00609 { return calloc (n, s); }
    00610
    00611 namespace CS
    00612 {
    00613   struct AllocPlatform {};
    00614   extern CS_CRYSTALSPACE_EXPORT const AllocPlatform allocPlatform;
    00615 }
    00620 extern CS_CRYSTALSPACE_EXPORT void* operator new (size_t s,
    00621   const CS::AllocPlatform&) throw();
    00626 extern CS_CRYSTALSPACE_EXPORT void* operator new[] (size_t s,
    00627   const CS::AllocPlatform&) throw();
    00628 extern CS_CRYSTALSPACE_EXPORT void operator delete (void* p,
    00629   const CS::AllocPlatform&) throw();
    00630 extern CS_CRYSTALSPACE_EXPORT void operator delete[] (void* p,
    00631   const CS::AllocPlatform&) throw();
    00633
    00634 #ifndef CS_NO_PTMALLOC
    00635
    00636
    00640 extern CS_CRYSTALSPACE_EXPORT void* ptmalloc (size_t n);
    00641 extern CS_CRYSTALSPACE_EXPORT void ptfree (void* p);
    00642 extern CS_CRYSTALSPACE_EXPORT void* ptrealloc (void* p, size_t n);
    00643 extern CS_CRYSTALSPACE_EXPORT void* ptcalloc (size_t n, size_t s);
    00645
    00651 CS_FORCEINLINE void* cs_malloc (size_t n)
    00652 { return ptmalloc (n); }
    00653 CS_FORCEINLINE void cs_free (void* p)
    00654 { ptfree (p); }
    00655 CS_FORCEINLINE void* cs_realloc (void* p, size_t n)
    00656 { return ptrealloc (p, n); }
    00657 CS_FORCEINLINE void* cs_calloc (size_t n, size_t s)
    00658 { return ptcalloc (n, s); }
    00660
    00678
    00683 #define CS_NO_NEW_OVERRIDE
    00684 #define CS_NO_MALLOC_OVERRIDE
    00685
    00686 #ifndef CS_NO_MALLOC_OVERRIDE
    00687 #define malloc          cs_malloc
    00688 #define free            cs_free
    00689 #define realloc         cs_realloc
    00690 #define calloc          cs_calloc
    00691 #endif // CS_NO_MALLOC_OVERRIDE
    00692
    00693 #ifndef CS_NO_NEW_OVERRIDE
    00694
    00695 #if !defined(CS_MEMORY_TRACKER) && !defined(CS_MEMORY_TRACKER_IMPLEMENT) \
    00696   && !defined(CS_EXTENSIVE_MEMDEBUG) && !defined(CS_EXTENSIVE_MEMDEBUG_IMPLEMENT)
    00697
    00698 #ifndef CS_NO_EXCEPTIONS
    00699 CS_FORCEINLINE void* operator new (size_t s) throw (std::bad_alloc)
    00700 {
    00701   void* p = ptmalloc (s);
    00702   if (!p) throw std::bad_alloc();
    00703   return p;
    00704 }
    00705 CS_FORCEINLINE void* operator new[] (size_t s) throw (std::bad_alloc)
    00706 {
    00707   void* p = ptmalloc (s);
    00708   if (!p) throw std::bad_alloc();
    00709   return p;
    00710 }
    00711 #else
    00712 CS_FORCEINLINE void* operator new (size_t s) throw ()
    00713 {
    00714   return ptmalloc (s);
    00715 }
    00716 CS_FORCEINLINE void* operator new[] (size_t s) throw ()
    00717 {
    00718   return ptmalloc (s);
    00719 }
    00720 #endif
    00721
    00722 CS_FORCEINLINE void operator delete (void* p) throw()
    00723 { ptfree (p); }
    00724 CS_FORCEINLINE void operator delete[] (void* p) throw()
    00725 { ptfree (p); }
    00726
    00727 CS_FORCEINLINE void* operator new (size_t s, const std::nothrow_t&) throw()
    00728 { return ptmalloc (s); }
    00729 CS_FORCEINLINE void* operator new[] (size_t s, const std::nothrow_t&) throw()
    00730 { return ptmalloc (s); }
    00731 CS_FORCEINLINE void operator delete (void* p, const std::nothrow_t&) throw()
    00732 { ptfree (p); }
    00733 CS_FORCEINLINE void operator delete[] (void* p, const std::nothrow_t&) throw()
    00734 { ptfree (p); }
    00735
    00736 #endif /* !defined(CS_MEMORY_TRACKER) && !defined(CS_MEMORY_TRACKER_IMPLEMENT)
    00737   && !defined(CS_EXTENSIVE_MEMDEBUG) && !defined(CS_EXTENSIVE_MEMDEBUG_IMPLEMENT) */
    00738 #endif // CS_NO_NEW_OVERRIDE
    00739
    00740 #else // CS_NO_PTMALLOC
    00741 CS_FORCEINLINE void* cs_malloc (size_t n)
    00742 { return platform_malloc (n); }
    00743 CS_FORCEINLINE void cs_free (void* p)
    00744 { platform_free (p); }
    00745 CS_FORCEINLINE void* cs_realloc (void* p, size_t n)
    00746 { return platform_realloc (p, n); }
    00747 CS_FORCEINLINE void* cs_calloc (size_t n, size_t s)
    00748 { return platform_calloc (n, s); }
    00749 #endif // CS_NO_PTMALLOC
    00750
    00751
    00752 #ifdef CS_USE_CUSTOM_ISDIR
    00753 static inline bool isdir (const char *path, struct dirent *de)
    00754 {
    00755   int pathlen = strlen (path);
    00756   char* fullname = new char[pathlen + 2 + strlen (de->d_name)];
    00757   memcpy (fullname, path, pathlen + 1);
    00758   if ((pathlen) && (fullname[pathlen-1] != CS_PATH_SEPARATOR))
    00759   {
    00760     fullname[pathlen++] = CS_PATH_SEPARATOR;
    00761     fullname[pathlen] = 0;
    00762   }
    00763   strcat (&fullname [pathlen], de->d_name);
    00764   struct stat st;
    00765   stat (fullname, &st);
    00766   delete[] fullname;
    00767   return ((st.st_mode & S_IFMT) == S_IFDIR);
    00768 }
    00769 #endif
    00770
    00771
    00772 // The following define should only be enabled if you have defined
    00773 // a special version of overloaded new that accepts two additional
    00774 // parameters: a (void*) pointing to the filename and an int with the
    00775 // line number. This is typically used for memory debugging.
    00776 // In csutil/memdebug.cpp there is a memory debugger which can (optionally)
    00777 // use this feature. Note that if CS_EXTENSIVE_MEMDEBUG is enabled while
    00778 // the memory debugger is not the memory debugger will still provide the
    00779 // needed overloaded operators so you can leave CS_EXTENSIVE_MEMDEBUG on in
    00780 // that case and the only overhead will be a little more arguments to 'new'.
    00781 // Do not enable CS_EXTENSIVE_MEMDEBUG if your platform or your own code
    00782 // defines its own 'new' operator, since this version will interfere with your
    00783 // own.
    00784 // CS_MEMORY_TRACKER is treated like CS_EXTENSIVE_MEMDEBUG here.
    00785 // Same for CS_REF_TRACKER.
    00786 #ifndef CS_DEBUG
    00787 #  undef CS_EXTENSIVE_MEMDEBUG
    00788 #  undef CS_REF_TRACKER
    00789 #else
    00790 #  if defined(CS_EXTENSIVE_MEMDEBUG) && defined(CS_MEMORY_TRACKER)
    00791 #    error Do not use CS_EXTENSIVE_MEMDEBUG and CS_MEMORY_TRACKER together!
    00792 #  endif
    00793 #endif
    00794 #if defined(CS_EXTENSIVE_MEMDEBUG) || defined(CS_MEMORY_TRACKER)
    00795 extern void* CS_CRYSTALSPACE_EXPORT operator new (size_t s,
    00796   void* filename, int line);
    00797 inline void operator delete (void* p, void*, int) { operator delete (p); }
    00798 extern void* CS_CRYSTALSPACE_EXPORT operator new[] (size_t s,
    00799   void* filename, int line);
    00800 inline void operator delete[] (void* p, void*, int) { operator delete[] (p); }
    00801
    00802 inline void* operator new (size_t s)
    00803 { return operator new (s, (void*)__FILE__, 0); }
    00804 inline void* operator new[] (size_t s)
    00805 { return operator new (s, (void*)__FILE__, 0); }
    00806
    00807 #define CS_EXTENSIVE_MEMDEBUG_NEW new ((void*)CS_FUNCTION_NAME, __LINE__)
    00808 #define new CS_EXTENSIVE_MEMDEBUG_NEW
    00809 #endif
    00810
    00811 #ifdef CS_DEBUG
    00812 #  if !defined (CS_DEBUG_BREAK)
    00813 #    if defined (CS_PLATFORM_WIN32)
    00814 #      define CS_DEBUG_BREAK ::DebugBreak()
    00815 #    elif defined (CS_PROCESSOR_X86)
    00816 #      if defined (CS_COMPILER_GCC)
    00817 #        define CS_DEBUG_BREAK asm ("int $3")
    00818 #      else
    00819 #        define CS_DEBUG_BREAK _asm int 3
    00820 #      endif
    00821 #    else
    00822 #      define CS_DEBUG_BREAK { static int x = 0; x /= x; }
    00823 #    endif
    00824 #  endif
    00825 #  if !defined (CS_ASSERT_MSG)
    00826     namespace CS
    00827     {
    00828       namespace Debug
    00829       {
    00830         extern void CS_CRYSTALSPACE_EXPORT AssertMessage (const char* expr,
    00831           const char* filename, int line, const char* msg = 0);
    00832       } // namespace Debug
    00833     } // namespace CS
    00834 #   define CS_ASSERT_MSG(msg,x)                                         \
    00835       if (!(x)) CS::Debug::AssertMessage (#x, __FILE__, __LINE__, msg);
    00836 #  endif
    00837 #  if !defined (CS_ASSERT)
    00838 #    define CS_ASSERT(x)        CS_ASSERT_MSG(0, x)
    00839 #  endif
    00840 #else
    00841 #  undef  CS_DEBUG_BREAK
    00842 #  define CS_DEBUG_BREAK
    00843 #  undef  CS_ASSERT
    00844 #  define CS_ASSERT(x)          (void)0
    00845 #  undef  CS_ASSERT_MSG
    00846 #  define CS_ASSERT_MSG(m,x)    (void)0
    00847 #endif
    00848
    00875 #if !defined(CS_DEPRECATED_METHOD) || defined(DOXYGEN_RUN)
    00876 #  if defined(CS_COMPILER_MSVC)
    00877 #    define CS_DEPRECATED_METHOD        __declspec(deprecated)
    00878       /* Unfortunately, MSVC is overzealous with warnings; it even emits one
    00879          when a deprecated method is overridden, e.g. when implementing an
    00880          interface method.
    00881          To work around this, use msvc_deprecated_warn_off.h/
    00882          msvc_deprecated_warn_on.h. */
    00883 #  else
    00884 #    define CS_DEPRECATED_METHOD
    00885 #  endif
    00886 #endif
    00887
    00892 #if !defined(CS_DEPRECATED_METHOD_MSG) || defined(DOXYGEN_RUN)
    00893 #  if defined(CS_COMPILER_MSVC) && _MSC_VER >= 1400
    00894 #    define CS_DEPRECATED_METHOD_MSG(msg) __declspec(deprecated(msg))
    00895 #  else
    00896 #    define CS_DEPRECATED_METHOD_MSG(msg) CS_DEPRECATED_METHOD
    00897 #  endif
    00898 #endif
    00899
    00910 #if !defined(CS_DEPRECATED_TYPE) || defined(DOXYGEN_RUN)
    00911 #  if defined(CS_COMPILER_MSVC)
    00912 #    define CS_DEPRECATED_TYPE __declspec(deprecated)
    00913 #  else
    00914 #    define CS_DEPRECATED_TYPE
    00915 #  endif
    00916 #endif
    00917
    00922 #if !defined(CS_DEPRECATED_TYPE_MSG) || defined(DOXYGEN_RUN)
    00923 #  if defined(CS_COMPILER_MSVC) && _MSC_VER >= 1400
    00924 #    define CS_DEPRECATED_TYPE_MSG(msg) __declspec(deprecated(msg))
    00925 #  else
    00926 #    define CS_DEPRECATED_TYPE_MSG(msg) CS_DEPRECATED_TYPE
    00927 #  endif
    00928 #endif
    00929
    00941 #if !defined(CS_CONST_METHOD) || defined(DOXYGEN_RUN)
    00942 #define CS_CONST_METHOD
    00943 #endif
    00944
    00957 #if !defined(CS_PURE_METHOD) || defined(DOXYGEN_RUN)
    00958 #define CS_PURE_METHOD
    00959 #endif
    00960
    00961 // Check if the csosdefs.h defined either CS_LITTLE_ENDIAN or CS_BIG_ENDIAN
    00962 #if !defined (CS_LITTLE_ENDIAN) && !defined (CS_BIG_ENDIAN)
    00963 #  error No CS_XXX_ENDIAN macro defined in your OS-specific csosdefs.h!
    00964 #endif
    00965
    00966 /*
    00967  * This is a bit of overkill but if you're sure your CPU doesn't require
    00968  * strict alignment add your CPU to the !defined below to get slightly
    00969  * smaller and faster code in some cases.
    00970  *
    00971  * \todo In the future, this should be moved to csconfig.h and determined as
    00972  * part of the configuration process.
    00973  */
    00974 #if defined (CS_PROCESSOR_SPARC)
    00975 #  define CS_STRICT_ALIGNMENT
    00976 #endif
    00977
    00978 // Adjust some definitions contained in csconfig.h
    00979 #if !defined (CS_PROCESSOR_X86) || !defined (CS_HAVE_NASM)
    00980 #  undef CS_HAVE_MMX
    00981 #  undef CS_HAVE_NASM
    00982 #endif
    00983
    00984 // Use special knowledge of IEEE float format in some cases for CPU's that are
    00985 // known to support it
    00986 #if !defined (CS_IEEE_DOUBLE_FORMAT)
    00987 #  if defined (CS_PROCESSOR_X86) || \
    00988       defined (CS_PROCESSOR_POWERPC) || \
    00989       defined (CS_PROCESSOR_MIPS) || \
    00990       defined (CS_PROCESSOR_SPARC) || \
    00991       defined (CS_PROCESSOR_ALPHA) || \
    00992       defined (CS_PROCESSOR_M68K)
    00993 #    define CS_IEEE_DOUBLE_FORMAT
    00994 #  endif
    00995 #endif
    00996
    00997 // gcc can perform usefull checking for printf/scanf format strings, just add
    00998 // this define at the end of the function declaration
    00999 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
    01000 #  define CS_GNUC_PRINTF(format_idx, arg_idx) \
    01001      __attribute__((format (__printf__, format_idx, arg_idx)))
    01002 #  define CS_GNUC_SCANF(format_idx, arg_idx) \
    01003      __attribute__((format (__scanf__, format_idx, arg_idx)))
    01004 // Unfortunately, gcc doesn't support format argument checking for wide strings
    01005 #  define CS_GNUC_WPRINTF(format_idx, arg_idx) \
    01006      /*__attribute__((format (__wprintf__, format_idx, arg_idx)))*/
    01007 #  define CS_GNUC_WSCANF(format_idx, arg_idx) \
    01008      /*__attribute__((format (__wscanf__, format_idx, arg_idx)))*/
    01009 #else
    01010 #  define CS_GNUC_PRINTF(format_idx, arg_idx)
    01011 #  define CS_GNUC_SCANF(format_idx, arg_idx)
    01012 #  define CS_GNUC_WPRINTF(format_idx, arg_idx)
    01013 #  define CS_GNUC_WSCANF(format_idx, arg_idx)
    01014 #endif
    01015
    01016 // Remove __attribute__ on non GNUC compilers.
    01017 #ifndef __GNUC__
    01018 #define __attribute__(x)
    01019 #endif
    01020
    01021 // Support for alignment and packing of structures.
    01022 #if !defined(CS_STRUCT_ALIGN_4BYTE_BEGIN)
    01023 #  if defined(__GNUC__) && defined(CS_STRICT_ALIGNMENT)
    01024 #    define CS_STRUCT_ALIGN_4BYTE_BEGIN
    01025 #    define CS_STRUCT_ALIGN_4BYTE_END __attribute__ ((aligned(4)))
    01026 #  else
    01027 #    define CS_STRUCT_ALIGN_4BYTE_BEGIN
    01028 #    define CS_STRUCT_ALIGN_4BYTE_END
    01029 #  endif
    01030 #endif
    01031
    01032 #if defined(CS_COMPILER_MSVC)
    01033   #define CS_ALIGNED_MEMBER(Member, Align)                              \
    01034     __declspec(align(Align)) Member
    01035 #elif defined(CS_COMPILER_GCC)
    01036
    01048   #define CS_ALIGNED_MEMBER(Member, Align)                              \
    01049     Member __attribute((aligned(Align)))
    01050 #else
    01051   #define CS_ALIGNED_MEMBER(Member, Align)      Member
    01052 #endif
    01053
    01054 // Macro used to define static implicit pointer conversion function.
    01055 // Only use within a class declaration.
    01056 #ifndef _CS_IMPLICITPTRCAST_NAME
    01057 #  define _CS_IMPLICITPTRCAST_NAME __ImplicitPtrCast
    01058 #endif
    01059
    01081 #define CS_IMPLEMENT_IMPLICIT_PTR_CAST(classname) \
    01082   inline static classname* _CS_IMPLICITPTRCAST_NAME (classname* ptr) \
    01083   { \
    01084     return ptr;\
    01085   }
    01086
    01095 #define CS_IMPLICIT_PTR_CAST(classname, ptr) \
    01096   (classname::_CS_IMPLICITPTRCAST_NAME(ptr))
    01097
    01101 #ifdef CS_HAVE_VA_COPY
    01102 #  define CS_VA_COPY(dest, src)         va_copy(dest, src)
    01103 #else
    01104 #  ifdef CS_HAVE___VA_COPY
    01105 #    define CS_VA_COPY(dest, src)       __va_copy(dest, src)
    01106 #  else
    01107 #    define CS_VA_COPY(dest, src)       dest = src;
    01108 #  endif
    01109 #endif
    01110
    01111 #define CS_STRING_TO_WIDE_(x)   L ## x
    01112
    01119 #define CS_STRING_TO_WIDE(x)    CS_STRING_TO_WIDE_(x)
    01120
    01121 #ifdef PACKAGE_NAME
    01122 # define CS_NAMESPACE_PACKAGE_NAME       PACKAGE_NAME
    01123 #else
    01124 # define CS_NAMESPACE_PACKAGE_NAME       CS
    01125 #endif
    01126
    01150 #define CS_PLUGIN_NAMESPACE_BEGIN(name)                                     \
    01151   namespace CS_NAMESPACE_PACKAGE_NAME { namespace Plugin { namespace name
    01152 #define CS_PLUGIN_NAMESPACE_END(name)                                       \
    01153   } }
    01154 #define CS_PLUGIN_NAMESPACE_NAME(name)                                      \
    01155   CS_NAMESPACE_PACKAGE_NAME::Plugin::name
    01156
    01158 #endif // __CS_CSSYSDEF_H__