CrystalSpace

Public API Reference

cssysdef.h
Go to the documentation of this file.
00001 /*
00002     Copyright (C) 1998-2008 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 /* Check whether shared or static libs should be used.
00037    Relevant defines are CS_USE_SHARED_LIBS, CS_USE_STATIC_LIBS and 
00038    CS_BUILD_SHARED_LIBS. While building CS they indicate whether CS is built
00039    with shared or static libs; while building external applications they
00040    indicate whether the used CS was built with shared or static libs.
00041    
00042    The reason for this multitude of defines is historical: first, there was
00043    CS_BUILD_SHARED_LIBS (default being absent). However, the name is not very
00044    clear when seen in the context of external projects (as CS isn't built there,
00045    and it doesn't control the building of the external project). Hence,
00046    the somewhat clearer CS_USE_SHARED_LIBS was added. CS_USE_STATIC_LIBS was
00047    added to provide an orthogonal definition to make clear static libs are
00048    used.
00049    Lastly, the defaults have changed: if none of the macros are defined the
00050    default is CS_USE_SHARED_LIBS. The reason is that, nowadays, shared libs
00051    are the default on most platforms anyway. (Especially on MSVC people tend
00052    to overlook to set the CS_BUILD_SHARED_LIBS define for an external project 
00053    and experience build errors.)
00054  */
00055  
00056 /* CS_USE_ defines have first control over shared lib building, override
00057    legacy CS_BUILD_SHARED_LIBS accordingly */
00058 #if defined(CS_USE_SHARED_LIBS)
00059 #  if !defined(CS_BUILD_SHARED_LIBS)
00060 #    define CS_BUILD_SHARED_LIBS
00061 #  endif
00062 #elif defined(CS_USE_STATIC_LIBS)
00063 #  if defined(CS_BUILD_SHARED_LIBS)
00064 #    undef CS_BUILD_SHARED_LIBS
00065 #  endif
00066 #endif
00067 /* If no CS_USE_ macro is defined and no CS_BUILD_SHARED_LIBS either, default
00068    to CS_USE_SHARED_LIBS */
00069 #if !defined(CS_USE_SHARED_LIBS) && !defined(CS_USE_STATIC_LIBS)
00070 #  if !defined(CS_BUILD_SHARED_LIBS)
00071 #    define CS_BUILD_SHARED_LIBS
00072 #  endif
00073 #  define CS_USE_SHARED_LIBS
00074 #endif
00075 // Sanity check
00076 #if defined(CS_USE_SHARED_LIBS) && defined(CS_USE_STATIC_LIBS)
00077 #  error Both CS_USE_SHARED_LIBS and CS_USE_STATIC_LIBS defined, please pick one!
00078 #endif
00079 
00080 /*
00081  * Pull in platform-specific overrides of the requested functionality.
00082  */
00083 #include "csutil/csosdefs.h"
00084 
00085 // Defaults for platforms that do not define their own.
00086 #ifndef CS_VISIBILITY_DEFAULT
00087 #  define CS_VISIBILITY_DEFAULT
00088 #endif
00089 #ifndef CS_VISIBILITY_HIDDEN
00090 #  define CS_VISIBILITY_HIDDEN
00091 #endif
00092 #ifndef CS_EXPORT_SYM_DLL
00093 #  define CS_EXPORT_SYM_DLL CS_VISIBILITY_DEFAULT
00094 #endif
00095 #ifndef CS_IMPORT_SYM_DLL
00096 #  define CS_IMPORT_SYM_DLL extern
00097 #endif
00098 #ifndef CS_EXPORT_SYM
00099 #  if defined(CS_USE_SHARED_LIBS)
00100 #    define CS_EXPORT_SYM CS_VISIBILITY_DEFAULT
00101 #  else
00102 #    define CS_EXPORT_SYM
00103 #  endif
00104 #endif
00105 #ifndef CS_IMPORT_SYM
00106 #  define CS_IMPORT_SYM
00107 #endif
00108 
00109 #include "csextern.h"
00110 
00111 /* On MinGW, with some versions of the MinGW runtime (3.15 and above), using
00112    the STL together with -ansi is broken: the C runtime functions swprintf()
00113    and vswprintf() are not declared, but an STL header (<cwchar>)
00114    unconditionally references it via 'using'.
00115    To work around the problem provide our own dummy declarations of these
00116    functions. */
00117 #if defined(__STRICT_ANSI__) && \
00118     (defined(CS_ANSI_BREAKS_SWPRINTF) || defined(CS_ANSI_BREAKS_VSWPRINTF))
00119 #if defined(CS_ANSI_BREAKS_SWPRINTF)
00120 int swprintf ();
00121 #endif
00122 #if defined(CS_ANSI_BREAKS_VSWPRINTF)
00123 int vswprintf ();
00124 #endif
00125 #include <cwchar>
00126 #endif
00127 
00128 /*
00129  * Default definitions for requested functionality.  Platform-specific
00130  * configuration files may override these.
00131  */
00132 
00133 #ifndef CS_FORCEINLINE
00134 # ifdef CS_COMPILER_GCC
00135 #  define CS_FORCEINLINE inline __attribute__((always_inline))
00136 #  if (__GNUC__ == 3) && (__GNUC_MINOR__ == 4)
00137     // Work around a gcc 3.4 issue where forcing inline doesn't always work
00138 #   define CS_FORCEINLINE_TEMPLATEMETHOD inline
00139 #  endif
00140 # else
00141 #  define CS_FORCEINLINE inline
00142 # endif
00143 #endif
00144 #ifndef CS_FORCEINLINE_TEMPLATEMETHOD
00145 # define CS_FORCEINLINE_TEMPLATEMETHOD CS_FORCEINLINE
00146 #endif
00147 
00152 #ifndef CS_ATTRIBUTE_MALLOC
00153 # define CS_ATTRIBUTE_MALLOC
00154 #endif
00155 
00159 #ifndef CS_ATTRIBUTE_INIT_PRIORITY
00160 # define CS_ATTRIBUTE_INIT_PRIORITY(PRI)
00161 #endif
00162 
00163 // Set up deprecation macros
00164 #ifdef CS_COMPILER_GCC
00165 #  define CS_DEPRECATED_METHOD    CS_ATTRIBUTE_DEPRECATED
00166 #  define CS_DEPRECATED_TYPE      CS_ATTRIBUTE_DEPRECATED
00167 #  define CS_DEPRECATED_VAR(decl) decl CS_ATTRIBUTE_DEPRECATED
00168 #  ifdef CS_ATTRIBUTE_DEPRECATED_MSG
00169 #    define CS_DEPRECATED_METHOD_MSG(msg)       CS_ATTRIBUTE_DEPRECATED_MSG(msg)
00170 #    define CS_DEPRECATED_TYPE_MSG(msg)         CS_ATTRIBUTE_DEPRECATED_MSG(msg)
00171 #    define CS_DEPRECATED_VAR_MSG(msg, decl)    decl CS_ATTRIBUTE_DEPRECATED_MSG(msg)
00172 #  endif
00173 #endif
00174 
00186 #if !defined(CS_DEPRECATED_METHOD) || defined(DOXYGEN_RUN)
00187 #  if defined(CS_COMPILER_MSVC)
00188 #    define CS_DEPRECATED_METHOD        __declspec(deprecated)
00189       /* Unfortunately, MSVC is overzealous with warnings; it even emits one 
00190          when a deprecated method is overridden, e.g. when implementing an 
00191          interface method. 
00192          To work around this, use msvc_deprecated_warn_off.h/
00193          msvc_deprecated_warn_on.h. */
00194 #  else
00195 #    define CS_DEPRECATED_METHOD
00196 #  endif
00197 #endif
00198 
00203 #if !defined(CS_DEPRECATED_METHOD_MSG) || defined(DOXYGEN_RUN)
00204 #  if defined(CS_COMPILER_MSVC) && _MSC_VER >= 1400
00205 #    define CS_DEPRECATED_METHOD_MSG(msg) __declspec(deprecated(msg))
00206 #  else
00207 #    define CS_DEPRECATED_METHOD_MSG(msg) CS_DEPRECATED_METHOD
00208 #  endif
00209 #endif
00210 
00221 #if !defined(CS_DEPRECATED_TYPE) || defined(DOXYGEN_RUN)
00222 #  if defined(CS_COMPILER_MSVC)
00223 #    define CS_DEPRECATED_TYPE __declspec(deprecated)
00224 #  else
00225 #    define CS_DEPRECATED_TYPE
00226 #  endif
00227 #endif
00228 
00233 #if !defined(CS_DEPRECATED_TYPE_MSG) || defined(DOXYGEN_RUN)
00234 #  if defined(CS_COMPILER_MSVC) && _MSC_VER >= 1400
00235 #    define CS_DEPRECATED_TYPE_MSG(msg) __declspec(deprecated(msg))
00236 #  else
00237 #    define CS_DEPRECATED_TYPE_MSG(msg) CS_DEPRECATED_TYPE
00238 #  endif
00239 #endif
00240 
00254 #if !defined(CS_DEPRECATED_VAR) || defined(DOXYGEN_RUN)
00255 #  if defined(CS_COMPILER_MSVC)
00256 #    define CS_DEPRECATED_VAR(decl) __declspec(deprecated) decl
00257 #  else
00258 #    define CS_DEPRECATED_VAR(decl) decl
00259 #  endif
00260 #endif
00261 
00266 #if !defined(CS_DEPRECATED_VAR_MSG) || defined(DOXYGEN_RUN)
00267 #  if defined(CS_COMPILER_MSVC) && _MSC_VER >= 1400
00268 #    define CS_DEPRECATED_VAR_MSG(msg, decl) __declspec(deprecated(msg)) decl
00269 #  else
00270 #    define CS_DEPRECATED_VAR_MSG(msg, decl) CS_DEPRECATED_VAR(decl)
00271 #  endif
00272 #endif
00273 
00278 #if defined(CS_COMPILER_MSVC) 
00279   #include <exception>
00280   #if !_HAS_EXCEPTIONS
00281     #define CS_NO_EXCEPTIONS
00282   #endif
00283 #elif defined(CS_COMPILER_GCC) && !defined(__EXCEPTIONS)
00284   #define CS_NO_EXCEPTIONS
00285 #endif
00286 
00291 #ifndef CS_MAXPATHLEN
00292 #define CS_MAXPATHLEN 1024
00293 #endif
00294 #include <stdio.h>
00295 #ifdef CS_HAVE_SYS_PARAM_H
00296 #include <sys/param.h>
00297 #endif
00298 
00305 #if defined(CS_COMPILER_GCC) && !defined(__STRICT_ANSI__)
00306 // In GCC we are able to declare stack vars of dynamic size directly
00307 #  define CS_ALLOC_STACK_ARRAY(type, var, size) \
00308      type var [size]
00309 #else
00310 #  include <stdlib.h>
00311 #  define CS_ALLOC_STACK_ARRAY(type, var, size) \
00312      type *var = (type *)alloca ((size) * sizeof (type))
00313 #  if defined(CS_COMPILER_GCC) && defined(__STRICT_ANSI__) && !defined(alloca)
00314 #    define alloca(x) __builtin_alloca(x)
00315 #  endif
00316 #endif
00317 
00318 
00342 #define CS_HEADER_GLOBAL(X,Y) CS_HEADER_GLOBAL_COMPOSE(X,Y)
00343 #define CS_HEADER_GLOBAL_COMPOSE(X,Y) <X/Y>
00344 
00357 #define CS_HEADER_LOCAL(X,Y) CS_HEADER_LOCAL_COMPOSE1(X,Y)
00358 #define CS_HEADER_LOCAL_COMPOSE1(X,Y) CS_HEADER_LOCAL_COMPOSE2(X/Y)
00359 #define CS_HEADER_LOCAL_COMPOSE2(X) #X
00360 
00361 
00367 #if !defined(CS_EXPORTED_FUNCTION)
00368 #  if defined(CS_STATIC_LINKED)
00369 #    define CS_EXPORTED_FUNCTION extern "C"
00370 #  else
00371 #    define CS_EXPORTED_FUNCTION extern "C" CS_EXPORT_SYM_DLL
00372 #  endif
00373 #endif
00374 
00386 #if !defined(CS_EXPORTED_NAME)
00387 #  define CS_EXPORTED_NAME(Prefix, Suffix) Prefix ## Suffix
00388 #endif
00389 
00390 #ifndef CS_IMPLEMENT_PLATFORM_PLUGIN
00391 #  define CS_IMPLEMENT_PLATFORM_PLUGIN
00392 #endif
00393 
00394 #ifndef CS_IMPLEMENT_PLATFORM_APPLICATION
00395 #  define CS_IMPLEMENT_PLATFORM_APPLICATION
00396 #endif
00397 
00404 #ifndef CS_INITIALIZE_PLATFORM_APPLICATION
00405 #  define CS_INITIALIZE_PLATFORM_APPLICATION /* */
00406 /*
00407   This definition may seem odd, but it's here for doxygen's sake, which
00408   apparently fails to document empty macro definitions.
00409  */
00410 #endif
00411 
00412 typedef void (*csStaticVarCleanupFN) (void (*p)());
00413 extern csStaticVarCleanupFN csStaticVarCleanup;
00414 
00415 #include "csutil/threading/atomicops.h"
00416 #include "csutil/threading/mutex.h"
00417 
00418 #define CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION_A(Name, FuncAttr)    \
00419 static CS::Threading::Mutex Name_ ## staticVarLock;                    \
00420 FuncAttr void Name (void (*p)())                                       \
00421 {                                                                      \
00422   CS::Threading::MutexScopedLock lock (Name_ ## staticVarLock);        \
00423   static void (**a)() = 0;                                             \
00424   static int lastEntry = 0;                                            \
00425   static int maxEntries = 0;                                           \
00426                                                                        \
00427   if (p != 0)                                                          \
00428   {                                                                    \
00429     if (lastEntry >= maxEntries)                                       \
00430     {                                                                  \
00431       maxEntries += 10;                                                \
00432       if (a == 0)                                                      \
00433         a = (void (**)())malloc(maxEntries * sizeof(void*));           \
00434       else                                                             \
00435         a = (void (**)())realloc(a, maxEntries * sizeof(void*));       \
00436     }                                                                  \
00437     a[lastEntry++] = p;                                                \
00438   }                                                                    \
00439   else if (a != 0)                                                     \
00440   {                                                                    \
00441     for (int i = lastEntry - 1; i >= 0; i--)                           \
00442       a[i] ();                                                         \
00443     free (a);                                                          \
00444     a = 0;                                                             \
00445     lastEntry = 0;                                                     \
00446     maxEntries = 0;                                                    \
00447   }                                                                    \
00448 }
00449 #ifndef CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION
00450 #  define CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION(Name)              \
00451       CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION_A(Name, )
00452 #endif
00453 
00454 #ifndef CS_DEFINE_STATIC_VARIABLE_REGISTRATION
00455 #  define CS_DEFINE_STATIC_VARIABLE_REGISTRATION(func) \
00456     csStaticVarCleanupFN csStaticVarCleanup = &func
00457 #endif
00458 
00459 #ifndef CS_DECLARE_STATIC_VARIABLE_REGISTRATION
00460 #  define CS_DECLARE_STATIC_VARIABLE_REGISTRATION(func) \
00461     void func (void (*p)())
00462 #endif
00463 
00464 #ifndef CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION
00465 #  define CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION               \
00466     CS_CRYSTALSPACE_EXPORT                                              \
00467     CS_DECLARE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);
00468 #endif
00469 
00470 #if defined(CS_EXTENSIVE_MEMDEBUG) || defined(CS_MEMORY_TRACKER)
00471 #  define CS_DEFINE_MEMTRACKER_MODULE             \
00472   class csMemTrackerModule;                       \
00473   namespace CS                                    \
00474   {                                               \
00475     namespace Debug                               \
00476     {                                             \
00477       namespace MemTracker                        \
00478       {                                           \
00479         namespace Impl                            \
00480         {                                         \
00481           csMemTrackerModule* thisModule = 0;     \
00482         }                                         \
00483       }                                           \
00484     }                                             \
00485   }
00486 #else
00487 #  define CS_DEFINE_MEMTRACKER_MODULE
00488 #endif
00489 
00509 #ifndef CS_IMPLEMENT_FOREIGN_DLL
00510 #  if defined(CS_BUILD_SHARED_LIBS)
00511 #    define CS_IMPLEMENT_FOREIGN_DLL                                        \
00512        CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION(csStaticVarCleanup_local); \
00513        CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_local);   \
00514        CS_DEFINE_MEMTRACKER_MODULE
00515 #  else
00516 #    define CS_IMPLEMENT_FOREIGN_DLL                                        \
00517        CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION                      \
00518        CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);  \
00519        CS_DEFINE_MEMTRACKER_MODULE
00520 #  endif
00521 #endif
00522 
00531 #if defined(CS_STATIC_LINKED)
00532 
00533 #  ifndef CS_IMPLEMENT_PLUGIN
00534 #  define CS_IMPLEMENT_PLUGIN                                           \
00535           CS_IMPLEMENT_PLATFORM_PLUGIN 
00536 #  endif
00537 
00538 #elif !defined(CS_BUILD_SHARED_LIBS)
00539 
00540 #  ifndef CS_IMPLEMENT_PLUGIN
00541 #  define CS_IMPLEMENT_PLUGIN                                           \
00542           CS_IMPLEMENT_PLATFORM_PLUGIN                                  \
00543           CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION               \
00544           CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);   \
00545           CS_DEFINE_MEMTRACKER_MODULE
00546 #  endif
00547 
00548 #else
00549 
00550 #  ifndef CS_IMPLEMENT_PLUGIN
00551 #  define CS_IMPLEMENT_PLUGIN                                           \
00552    CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION(csStaticVarCleanup_local)  \
00553    CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_local);   \
00554    CS_IMPLEMENT_PLATFORM_PLUGIN                                         \
00555    CS_DEFINE_MEMTRACKER_MODULE
00556 #  endif
00557 
00558 #endif
00559 
00568 #ifndef CS_IMPLEMENT_APPLICATION
00569 #  define CS_IMPLEMENT_APPLICATION                                      \
00570   CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION                       \
00571   CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);   \
00572   CS_IMPLEMENT_PLATFORM_APPLICATION                                     \
00573   CS_DEFINE_MEMTRACKER_MODULE
00574 #endif
00575 
00579 #ifndef CS_REGISTER_STATIC_FOR_DESTRUCTION
00580 #define CS_REGISTER_STATIC_FOR_DESTRUCTION(getterFunc)\
00581         csStaticVarCleanup (getterFunc);
00582 #endif
00583 
00587 #ifndef CS_STATIC_VARIABLE_CLEANUP
00588 #define CS_STATIC_VARIABLE_CLEANUP  \
00589         csStaticVarCleanup (0);
00590 #endif
00591 
00592 /* Body of getter function, mostly the same across different CS_STATIC_VAR_*
00593   variants.
00594   'Ptr' is a variable of type 'Type*' that receives the value of 'Val' (where
00595   the actual object is stored). See CS_IMPLEMENT_STATIC_VAR for explanation
00596   of initParam and kill_how.
00597   
00598   'Val' is read atomically. If it's 0, a new object is created. If another
00599   thread concurrently requests the value, it's ensured that the value is
00600   consistent (both the returned and stored value).
00601 */
00602 #define CS_STATIC_VAR_GETTER_COMMON(Type, Ptr, initParam, Val, kill_how)\
00603   while (true)                                                          \
00604   {                                                                     \
00605     Ptr = reinterpret_cast<Type*> (                                     \
00606       CS::Threading::AtomicOperations::Read (                           \
00607         reinterpret_cast<void**> (&Val)));                              \
00608     if (Ptr != 0) break;                                                \
00609     Ptr = new Type initParam;                                           \
00610     if (CS::Threading::AtomicOperations::CompareAndSet (                \
00611         reinterpret_cast<void**> (&Val), Ptr, 0) != 0)                  \
00612     {                                                                   \
00613       delete Ptr;                                                       \
00614     }                                                                   \
00615     else                                                                \
00616     {                                                                   \
00617       csStaticVarCleanup (kill_how);                                    \
00618       break;                                                            \
00619     }                                                                   \
00620   }
00621 
00634 #ifndef CS_IMPLEMENT_STATIC_VAR_EXT
00635 #define CS_IMPLEMENT_STATIC_VAR_EXT(getterFunc,Type,initParam,kill_how) \
00636 namespace {                                                             \
00637 static Type* getterFunc ## _v = 0;                                      \
00638 static Type* getterFunc ();                                             \
00639 static void getterFunc ## _kill ();                                     \
00640 static void getterFunc ## _kill_array ();                               \
00641 void getterFunc ## _kill ()                                             \
00642 {                                                                       \
00643   (void)(&getterFunc ## _kill_array);                                   \
00644   delete getterFunc ## _v;                                              \
00645   getterFunc ## _v = 0;                                                 \
00646 }                                                                       \
00647 void getterFunc ## _kill_array ()                                       \
00648 {                                                                       \
00649   (void)(&getterFunc ## _kill);                                         \
00650   delete [] getterFunc ## _v;                                           \
00651   getterFunc ## _v = 0;                                                 \
00652 }                                                                       \
00653 Type* getterFunc ()                                                     \
00654 {                                                                       \
00655   Type* p;                                                              \
00656   CS_STATIC_VAR_GETTER_COMMON(Type, p, initParam, getterFunc ## _v,     \
00657     getterFunc ## kill_how);                                            \
00658   return p;                                                             \
00659 }                                                                       \
00660 }
00661 #endif
00662 
00663 #ifndef CS_IMPLEMENT_STATIC_VAR
00664 #define CS_IMPLEMENT_STATIC_VAR(getterFunc,Type,initParam) \
00665  CS_IMPLEMENT_STATIC_VAR_EXT(getterFunc,Type,initParam,_kill)    
00666 #endif
00667 
00668 #ifndef CS_IMPLEMENT_STATIC_VAR_ARRAY
00669 #define CS_IMPLEMENT_STATIC_VAR_ARRAY(getterFunc,Type,initParam) \
00670  CS_IMPLEMENT_STATIC_VAR_EXT(getterFunc,Type,initParam,_kill_array)    
00671 #endif
00672 
00680 #ifndef CS_DECLARE_STATIC_CLASSVAR
00681 #define CS_DECLARE_STATIC_CLASSVAR(var,getterFunc,Type)       \
00682 static Type *var;                                             \
00683 static Type *getterFunc ();                                   \
00684 static void getterFunc ## _kill ();                           \
00685 static void getterFunc ## _kill_array ();
00686 #endif
00687 
00688 #ifndef CS_DECLARE_STATIC_CLASSVAR_REF
00689 #define CS_DECLARE_STATIC_CLASSVAR_REF(var,getterFunc,Type)   \
00690 static Type *var;                                             \
00691 static Type &getterFunc ();                                   \
00692 static void getterFunc ## _kill ();                           \
00693 static void getterFunc ## _kill_array ();
00694 #endif
00695 
00706 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_EXT
00707 #define CS_IMPLEMENT_STATIC_CLASSVAR_EXT(Class,var,getterFunc,Type,initParam,\
00708   kill_how)                                                     \
00709 Type* Class::var = 0;                                           \
00710 void Class::getterFunc ## _kill ()                              \
00711 {                                                               \
00712   delete getterFunc ();                                         \
00713   var = 0;                                                      \
00714 }                                                               \
00715 void Class::getterFunc ## _kill_array ()                        \
00716 {                                                               \
00717   delete [] getterFunc ();                                      \
00718   var = 0;                                                      \
00719 }                                                               \
00720 Type* Class::getterFunc ()                                      \
00721 {                                                               \
00722   Type* p;                                                      \
00723   CS_STATIC_VAR_GETTER_COMMON(Type, p, initParam, var,          \
00724     getterFunc ## kill_how);                                    \
00725   return p;                                                     \
00726 }
00727 #endif
00728 
00729 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR
00730 #define CS_IMPLEMENT_STATIC_CLASSVAR(Class,var,getterFunc,Type,initParam) \
00731   CS_IMPLEMENT_STATIC_CLASSVAR_EXT(Class,var,getterFunc,Type,initParam,_kill)
00732 #endif
00733 
00734 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_ARRAY
00735 #define CS_IMPLEMENT_STATIC_CLASSVAR_ARRAY(Class,var,getterFunc,Type,\
00736   initParam) \
00737   CS_IMPLEMENT_STATIC_CLASSVAR_EXT(Class,var,getterFunc,Type,initParam,\
00738     _kill_array)
00739 #endif
00740 
00741 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT
00742 #define CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT(Class,var,getterFunc,Type,\
00743   initParam,kill_how) \
00744 Type *Class::var = 0;                                          \
00745 void Class::getterFunc ## _kill ()                             \
00746 {                                                              \
00747   delete &getterFunc ();                                       \
00748   var = 0;                                                     \
00749 }                                                              \
00750   void Class::getterFunc ## _kill_array ()                     \
00751 {                                                              \
00752   delete [] &getterFunc ();                                    \
00753   var = 0;                                                     \
00754 }                                                              \
00755 Type &Class::getterFunc ()                                     \
00756 {                                                              \
00757   Type* p;                                                      \
00758   CS_STATIC_VAR_GETTER_COMMON(Type, p, initParam, var,          \
00759     getterFunc ## kill_how);                                    \
00760   return *p;                                                    \
00761 }
00762 #endif
00763 
00764 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_REF
00765 #define CS_IMPLEMENT_STATIC_CLASSVAR_REF(Class,var,getterFunc,Type,initParam)\
00766   CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT(Class,var,getterFunc,Type,\
00767     initParam,_kill)
00768 #endif
00769 
00770 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_REF_ARRAY
00771 #define CS_IMPLEMENT_STATIC_CLASSVAR_REF_ARRAY(Class,var,getterFunc,Type,\
00772   initParam) \
00773   CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT(Class,var,getterFunc,Type,initParam,\
00774     _kill_array)
00775 #endif
00776 
00781 #if defined(CS_COMPILER_GCC)
00782 #  define CS_FUNCTION_NAME              __PRETTY_FUNCTION__
00783 #elif defined(__FUNCTION__)
00784 #  define CS_FUNCTION_NAME              __FUNCTION__
00785 #else
00786 #  define CS_FUNCTION_NAME              "<?\?\?>"
00787 #endif
00788 
00789 #include <stdlib.h>
00790 #ifdef CS_HAVE_MALLOC_H
00791 #include <malloc.h>
00792 #endif
00793 #include <new>
00794 
00795 #ifndef CS_NO_PTMALLOC
00796 
00797 
00801 extern CS_CRYSTALSPACE_EXPORT CS_ATTRIBUTE_MALLOC void* ptmalloc (size_t n);
00802 extern CS_CRYSTALSPACE_EXPORT void ptfree (void* p);
00803 extern CS_CRYSTALSPACE_EXPORT void* ptrealloc (void* p, size_t n);
00804 extern CS_CRYSTALSPACE_EXPORT CS_ATTRIBUTE_MALLOC void* ptcalloc (size_t n,
00805   size_t s);
00807 
00809 
00813 extern CS_CRYSTALSPACE_EXPORT CS_ATTRIBUTE_MALLOC void* ptmalloc_sentinel (
00814   size_t n);
00815 extern CS_CRYSTALSPACE_EXPORT void ptfree_sentinel (void* p);
00816 extern CS_CRYSTALSPACE_EXPORT void* ptrealloc_sentinel (void* p, size_t n);
00817 extern CS_CRYSTALSPACE_EXPORT CS_ATTRIBUTE_MALLOC void* ptcalloc_sentinel (
00818   size_t n, size_t s);
00820 
00822 
00826 extern CS_CRYSTALSPACE_EXPORT CS_ATTRIBUTE_MALLOC void* ptmalloc_located (
00827   size_t n);
00828 extern CS_CRYSTALSPACE_EXPORT void ptfree_located (void* p);
00829 extern CS_CRYSTALSPACE_EXPORT void* ptrealloc_located (void* p, size_t n);
00830 extern CS_CRYSTALSPACE_EXPORT CS_ATTRIBUTE_MALLOC void* ptcalloc_located (
00831   size_t n, size_t s);
00833 
00835 
00839 extern CS_CRYSTALSPACE_EXPORT CS_ATTRIBUTE_MALLOC void* ptmalloc_checking (
00840   size_t n);
00841 extern CS_CRYSTALSPACE_EXPORT void ptfree_checking (void* p);
00842 extern CS_CRYSTALSPACE_EXPORT void* ptrealloc_checking (void* p, size_t n);
00843 extern CS_CRYSTALSPACE_EXPORT CS_ATTRIBUTE_MALLOC void* ptcalloc_checking (
00844   size_t n, size_t s);
00846 
00847 #ifndef CS_DEBUG
00848 #  undef CS_EXTENSIVE_MEMDEBUG
00849 #  undef CS_REF_TRACKER
00850 #else
00851 #  if defined(CS_EXTENSIVE_MEMDEBUG) && defined(CS_MEMORY_TRACKER)
00852 #    error Do not use CS_EXTENSIVE_MEMDEBUG and CS_MEMORY_TRACKER together!
00853 #  endif
00854 #endif
00855 
00856 #endif // CS_NO_PTMALLOC
00857 
00863 extern CS_CRYSTALSPACE_EXPORT CS_ATTRIBUTE_MALLOC void* cs_malloc (size_t n);
00864 extern CS_CRYSTALSPACE_EXPORT void cs_free (void* p);
00865 extern CS_CRYSTALSPACE_EXPORT void* cs_realloc (void* p, size_t n);
00866 extern CS_CRYSTALSPACE_EXPORT void* cs_calloc (size_t n, size_t s);
00868 
00869 namespace CS
00870 {
00871   template <class T>
00872   class StackArrayHelper
00873   {
00874   private:
00875     void* memory;
00876     bool deleteme;
00877 
00878   public:
00879     StackArrayHelper (void* memory, bool deleteme)
00880       : memory (memory), deleteme (deleteme) { }
00881     ~StackArrayHelper () { if (deleteme) cs_free (memory); }
00882   };
00883 }
00884 
00894 #define CS_ALLOC_STACK_ARRAY_FALLBACK(Type, Name, Size, Thresshold) \
00895   Type* Name = ((Size) > (Thresshold)) ? \
00896         (Type*)cs_malloc((Size)*sizeof(Type)) : \
00897         (Type*)alloca((Size)*sizeof(Type)); \
00898   CS::StackArrayHelper<Type> Name##Del (Name, ((Size) > (Thresshold)));
00899 
00900 
00901 #ifdef CS_USE_CUSTOM_ISDIR
00902 static inline bool isdir (const char *path, struct dirent *de)
00903 {
00904   int pathlen = strlen (path);
00905   char* fullname = new char[pathlen + 2 + strlen (de->d_name)];
00906   memcpy (fullname, path, pathlen + 1);
00907   if ((pathlen) && (fullname[pathlen-1] != CS_PATH_SEPARATOR))
00908   {
00909     fullname[pathlen++] = CS_PATH_SEPARATOR;
00910     fullname[pathlen] = 0;
00911   }
00912   strcat (&fullname [pathlen], de->d_name);
00913   struct stat st;
00914   stat (fullname, &st);
00915   delete[] fullname;
00916   return ((st.st_mode & S_IFMT) == S_IFDIR);
00917 }
00918 #endif
00919 
00920 
00921 // The following define should only be enabled if you have defined
00922 // a special version of overloaded new that accepts two additional
00923 // parameters: a (void*) pointing to the filename and an int with the
00924 // line number. This is typically used for memory debugging.
00925 // In csutil/memdebug.cpp there is a memory debugger which can (optionally)
00926 // use this feature. Note that if CS_EXTENSIVE_MEMDEBUG is enabled while
00927 // the memory debugger is not the memory debugger will still provide the
00928 // needed overloaded operators so you can leave CS_EXTENSIVE_MEMDEBUG on in
00929 // that case and the only overhead will be a little more arguments to 'new'.
00930 // Do not enable CS_EXTENSIVE_MEMDEBUG if your platform or your own code
00931 // defines its own 'new' operator, since this version will interfere with your
00932 // own.
00933 // CS_MEMORY_TRACKER is treated like CS_EXTENSIVE_MEMDEBUG here.
00934 #if defined(CS_EXTENSIVE_MEMDEBUG) || defined(CS_MEMORY_TRACKER)
00935 extern CS_CRYSTALSPACE_EXPORT void operator delete (void* p);
00936 extern CS_CRYSTALSPACE_EXPORT void operator delete[] (void* p);
00937 
00938 extern CS_CRYSTALSPACE_EXPORT void* operator new (size_t s, 
00939   void* filename, int line);
00940 inline void operator delete (void* p, void*, int) { operator delete (p); }
00941 extern CS_CRYSTALSPACE_EXPORT void* operator new[] (size_t s, 
00942   void* filename, int line);
00943 inline void operator delete[] (void* p, void*, int) { operator delete[] (p); }
00944 
00945 inline void* operator new (size_t s)
00946 { return operator new (s, (void*)__FILE__, 0); }
00947 inline void* operator new[] (size_t s)
00948 { return operator new (s, (void*)__FILE__, 0); }
00949 
00950 #define CS_EXTENSIVE_MEMDEBUG_NEW new ((void*)CS_FUNCTION_NAME, __LINE__)
00951 #define new CS_EXTENSIVE_MEMDEBUG_NEW
00952 #endif
00953 
00954 namespace CS
00955 {
00956   namespace Debug
00957   {
00958     extern void CS_CRYSTALSPACE_EXPORT AssertMessage (const char* expr, 
00959       const char* filename, int line, const char* msg = 0);
00960     
00967     static inline void DebugBreak ()
00968     {
00969     #  if defined (CS_PLATFORM_WIN32)
00970       ::DebugBreak();
00971     #  else
00972       raise (SIGTRAP);
00973     #  endif
00974     }
00975     
00981     extern bool CS_CRYSTALSPACE_EXPORT VerifyAllMemory ();
00986     extern void CS_CRYSTALSPACE_EXPORT DumpAllocateMemoryBlocks ();
00987   } // namespace Debug
00988 } // namespace CS
00989 
00990 #if defined(CS_DEBUG) || defined(CS_WITH_ASSERTIONS)
00991 #  define CS_DEBUG_BREAK        CS::Debug::DebugBreak()
00992 #  if !defined (CS_ASSERT_MSG)
00993 #   define CS_ASSERT_MSG(msg,x)                                         \
00994       if (!(x)) CS::Debug::AssertMessage (#x, __FILE__, __LINE__, msg);
00995 #  endif
00996 #  if !defined (CS_ASSERT)
00997 #    define CS_ASSERT(x)        CS_ASSERT_MSG(0, x)
00998 #  endif
00999 #else
01000 #  undef  CS_DEBUG_BREAK
01001 #  define CS_DEBUG_BREAK
01002 #  undef  CS_ASSERT
01003 #  define CS_ASSERT(x)          (void)0
01004 #  undef  CS_ASSERT_MSG
01005 #  define CS_ASSERT_MSG(m,x)    (void)0
01006 #endif
01007 
01023 // Check if the csosdefs.h defined either CS_LITTLE_ENDIAN or CS_BIG_ENDIAN
01024 #if !defined (CS_LITTLE_ENDIAN) && !defined (CS_BIG_ENDIAN)
01025 #  error No CS_XXX_ENDIAN macro defined in your OS-specific csosdefs.h!
01026 #endif
01027 
01028 /*
01029  * This is a bit of overkill but if you're sure your CPU doesn't require
01030  * strict alignment add your CPU to the !defined below to get slightly
01031  * smaller and faster code in some cases.
01032  *
01033  * \todo In the future, this should be moved to csconfig.h and determined as
01034  * part of the configuration process.
01035  */
01036 #if defined (CS_PROCESSOR_SPARC)
01037 #  define CS_STRICT_ALIGNMENT
01038 #endif
01039 
01040 // Adjust some definitions contained in csconfig.h
01041 #if !defined (CS_PROCESSOR_X86) || !defined (CS_HAVE_NASM)
01042 #  undef CS_HAVE_MMX
01043 #  undef CS_HAVE_NASM
01044 #endif
01045 
01046 // Use special knowledge of IEEE float format in some cases for CPU's that are
01047 // known to support it
01048 #if !defined (CS_IEEE_DOUBLE_FORMAT)
01049 #  if defined (CS_PROCESSOR_X86) || \
01050       defined (CS_PROCESSOR_POWERPC) || \
01051       defined (CS_PROCESSOR_MIPS) || \
01052       defined (CS_PROCESSOR_SPARC) || \
01053       defined (CS_PROCESSOR_ALPHA) || \
01054       defined (CS_PROCESSOR_M68K) || \
01055       defined (CS_PROCESSOR_ARM)
01056 #    define CS_IEEE_DOUBLE_FORMAT
01057 #  endif
01058 #endif
01059 
01060 // gcc can perform usefull checking for printf/scanf format strings, just add
01061 // this define at the end of the function declaration
01062 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)
01063 /* Newer GCCs know different 'archetypes' of format string styles.
01064  * CS format strings are on the level of the GNU C library, so use that
01065  * archetype. */
01066 #  define CS_GNUC_PRINTF(format_idx, arg_idx) \
01067      __attribute__((format (gnu_printf, format_idx, arg_idx)))
01068 #  define CS_GNUC_SCANF(format_idx, arg_idx) \
01069      __attribute__((format (gnu_scanf, format_idx, arg_idx)))
01070 // Unfortunately, gcc doesn't support format argument checking for wide strings
01071 #  define CS_GNUC_WPRINTF(format_idx, arg_idx) \
01072      /*__attribute__((format (__wprintf__, format_idx, arg_idx)))*/
01073 #  define CS_GNUC_WSCANF(format_idx, arg_idx) \
01074      /*__attribute__((format (__wscanf__, format_idx, arg_idx)))*/
01075 #elif __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
01076 // Use default archetype for older versions.
01077 #  define CS_GNUC_PRINTF(format_idx, arg_idx) \
01078      __attribute__((format (__printf__, format_idx, arg_idx)))
01079 #  define CS_GNUC_SCANF(format_idx, arg_idx) \
01080      __attribute__((format (__scanf__, format_idx, arg_idx)))
01081 // Unfortunately, gcc doesn't support format argument checking for wide strings
01082 #  define CS_GNUC_WPRINTF(format_idx, arg_idx) \
01083      /*__attribute__((format (__wprintf__, format_idx, arg_idx)))*/
01084 #  define CS_GNUC_WSCANF(format_idx, arg_idx) \
01085      /*__attribute__((format (__wscanf__, format_idx, arg_idx)))*/
01086 #else
01087 #  define CS_GNUC_PRINTF(format_idx, arg_idx)
01088 #  define CS_GNUC_SCANF(format_idx, arg_idx)
01089 #  define CS_GNUC_WPRINTF(format_idx, arg_idx)
01090 #  define CS_GNUC_WSCANF(format_idx, arg_idx)
01091 #endif
01092 
01093 // Remove __attribute__ on non GNUC compilers.
01094 #ifndef __GNUC__
01095 #define __attribute__(x)
01096 #endif
01097 
01098 // Support for alignment and packing of structures.
01099 #if !defined(CS_STRUCT_ALIGN_4BYTE_BEGIN)
01100 #  if defined(__GNUC__) && defined(CS_STRICT_ALIGNMENT)
01101 #    define CS_STRUCT_ALIGN_4BYTE_BEGIN
01102 #    define CS_STRUCT_ALIGN_4BYTE_END __attribute__ ((aligned(4)))
01103 #  else
01104 #    define CS_STRUCT_ALIGN_4BYTE_BEGIN
01105 #    define CS_STRUCT_ALIGN_4BYTE_END
01106 #  endif
01107 #endif
01108 
01109 #if defined(CS_COMPILER_MSVC)
01110   #define CS_ALIGNED_MEMBER(Member, Align)                              \
01111     __declspec(align(Align)) Member
01112   #define CS_ALIGNED_STRUCT(Kind, Align)                                \
01113     __declspec(align(Align)) Kind
01114 #elif defined(CS_COMPILER_GCC)
01115 
01127   #define CS_ALIGNED_MEMBER(Member, Align)                              \
01128     Member __attribute__((aligned(Align)))
01129 
01140   #define CS_ALIGNED_STRUCT(Kind, Align)                                \
01141     Kind __attribute__((aligned(Align)))
01142 #else
01143   #define CS_ALIGNED_MEMBER(Member, Align)      Member
01144   #define CS_ALIGNED_STRUCT(Kind, Align)                Kind
01145 #endif
01146 
01147 // Macro used to define static implicit pointer conversion function.
01148 // Only use within a class declaration.
01149 #ifndef _CS_IMPLICITPTRCAST_NAME
01150 #  define _CS_IMPLICITPTRCAST_NAME __ImplicitPtrCast
01151 #endif
01152 
01174 #define CS_IMPLEMENT_IMPLICIT_PTR_CAST(classname) \
01175   inline static classname* _CS_IMPLICITPTRCAST_NAME (classname* ptr) \
01176   { \
01177     return ptr;\
01178   }
01179 
01188 #define CS_IMPLICIT_PTR_CAST(classname, ptr) \
01189   (classname::_CS_IMPLICITPTRCAST_NAME(ptr))
01190 
01194 #ifdef CS_HAVE_VA_COPY
01195 #  define CS_VA_COPY(dest, src)         va_copy(dest, src)
01196 #else
01197 #  ifdef CS_HAVE___VA_COPY
01198 #    define CS_VA_COPY(dest, src)       __va_copy(dest, src)
01199 #  else
01200 #    define CS_VA_COPY(dest, src)       dest = src;
01201 #  endif
01202 #endif
01203 
01204 #define CS_STRING_TO_WIDE_(x)   L ## x
01205 
01212 #define CS_STRING_TO_WIDE(x)    CS_STRING_TO_WIDE_(x)
01213 
01214 #ifdef PACKAGE_NAME
01215 # define CS_NAMESPACE_PACKAGE_NAME       PACKAGE_NAME
01216 #else
01217 # define CS_NAMESPACE_PACKAGE_NAME       CS
01218 #endif
01219 
01243 #define CS_PLUGIN_NAMESPACE_BEGIN(name)                                     \
01244   namespace CS_NAMESPACE_PACKAGE_NAME { namespace Plugin { namespace name
01245 #define CS_PLUGIN_NAMESPACE_END(name)                                       \
01246   } }
01247 #define CS_PLUGIN_NAMESPACE_NAME(name)                                      \
01248   CS_NAMESPACE_PACKAGE_NAME::Plugin::name
01249 
01262 #if defined(CS_COMPILER_GCC) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 1))
01263 # define CS_DEPRECATION_WARNINGS_DISABLE        \
01264   _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
01265 # define CS_DEPRECATION_WARNINGS_ENABLE \
01266   _Pragma("GCC diagnostic warning \"-Wdeprecated-declarations\"")
01267 #else
01268 # define CS_DEPRECATION_WARNINGS_DISABLE
01269 # define CS_DEPRECATION_WARNINGS_ENABLE
01270 #endif
01271 
01272 namespace CS
01273 {
01274   namespace deprecated
01275   {
01276     CS_DEPRECATED_METHOD_MSG("Use CS::Platform::CreateDirectory() instead")
01277     CS_CRYSTALSPACE_EXPORT int CS_MKDIR (const char* path);
01278   } // namespace deprecated
01279 } // namespace CS
01280 
01281 #define CS_MKDIR(path)    CS::deprecated::CS_MKDIR(path)
01282 
01283 // Include nullptr fallback (for convenience).
01284 #include "csutil/nullptr.h"
01285 
01286 #endif // __CS_CSSYSDEF_H__

Generated for Crystal Space 2.0 by doxygen 1.7.6.1