## 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_EXPORT_SYM_DLL
    00043 #  ifdef CS_VISIBILITY_DEFAULT
    00044 #    define CS_EXPORT_SYM_DLL CS_VISIBILITY_DEFAULT
    00045 #  else
    00046 #    define CS_EXPORT_SYM_DLL
    00047 #  endif
    00048 #endif
    00049 #ifndef CS_IMPORT_SYM_DLL
    00050 #  define CS_IMPORT_SYM_DLL extern
    00051 #endif
    00052 #ifndef CS_EXPORT_SYM
    00053 #  if defined(CS_VISIBILITY_DEFAULT) && defined(CS_BUILD_SHARED_LIBS)
    00054 #    define CS_EXPORT_SYM CS_VISIBILITY_DEFAULT
    00055 #  else
    00056 #    define CS_EXPORT_SYM
    00057 #  endif
    00058 #endif
    00059 #ifndef CS_IMPORT_SYM
    00060 #  define CS_IMPORT_SYM
    00061 #endif
    00062
    00063 #include "csextern.h"
    00064
    00065 /*
    00066  * Default definitions for requested functionality.  Platform-specific
    00067  * configuration files may override these.
    00068  */
    00069
    00070 #ifndef CS_FORCEINLINE
    00071 #define CS_FORCEINLINE inline
    00072 #endif
    00073
    00078 #ifndef CS_MAXPATHLEN
    00079 #define CS_MAXPATHLEN 1024
    00080 #endif
    00081 #include <stdio.h>
    00082 #ifdef CS_HAVE_SYS_PARAM_H
    00083 #include <sys/param.h>
    00084 #endif
    00085
    00092 #if defined(CS_COMPILER_GCC) && !defined(__STRICT_ANSI__)
    00093 // In GCC we are able to declare stack vars of dynamic size directly
    00094 #  define CS_ALLOC_STACK_ARRAY(type, var, size) \
    00095      type var [size]
    00096 #else
    00097 #  include <stdlib.h>
    00098 #  define CS_ALLOC_STACK_ARRAY(type, var, size) \
    00099      type *var = (type *)alloca ((size) * sizeof (type))
    00100 #  if defined(CS_COMPILER_GCC) && defined(__STRICT_ANSI__) && !defined(alloca)
    00101 #    define alloca(x) __builtin_alloca(x)
    00102 #  endif
    00103 #endif
    00104
    00108 #ifndef CS_TEMP_DIR
    00109 #  if defined(CS_PLATFORM_UNIX)
    00110 #    define CS_TEMP_DIR "/tmp/"
    00111 #  else
    00112 #    define CS_TEMP_DIR ""
    00113 #  endif
    00114 #endif
    00115
    00119 #ifndef CS_TEMP_FILE
    00120 #  if defined(CS_PLATFORM_UNIX)
    00121 #    define CS_TEMP_FILE "cs%lud.tmp", (unsigned long)getpid()
    00122 #  else
    00123 #    define CS_TEMP_FILE "$cs$.tmp"
    00124 #  endif
    00125 #endif
    00126
    00127 #ifdef CS_USE_CUSTOM_ISDIR
    00128 static inline bool isdir (const char *path, struct dirent *de)
    00129 {
    00130   int pathlen = strlen (path);
    00131   char* fullname = new char[pathlen + 2 + strlen (de->d_name)];
    00132   memcpy (fullname, path, pathlen + 1);
    00133   if ((pathlen) && (fullname[pathlen-1] != CS_PATH_SEPARATOR))
    00134   {
    00135     fullname[pathlen++] = CS_PATH_SEPARATOR;
    00136     fullname[pathlen] = 0;
    00137   }
    00138   strcat (&fullname [pathlen], de->d_name);
    00139   struct stat st;
    00140   stat (fullname, &st);
    00141   delete[] fullname;
    00142   return ((st.st_mode & S_IFMT) == S_IFDIR);
    00143 }
    00144 #endif
    00145
    00154 // Handle platforms with no native aligned malloc
    00155 #ifndef CS_HAVE_CSALIGNED_MALLOC
    00156 static inline void* csAlignedMalloc (size_t size, size_t align)
    00157 {
    00158   void *mallocPtr = malloc(size + align + sizeof(void*));
    00159   size_t ptrInt = (size_t)mallocPtr;
    00160
    00161   ptrInt = (ptrInt + align + sizeof(void*)) / align * align;
    00162   *(((void**)ptrInt) - 1) = mallocPtr;
    00163
    00164   return (void*)ptrInt;
    00165 }
    00166
    00167 static inline void csAlignedFree (void* ptr)
    00168 {
    00169   free(*(((void**)ptr) - 1));
    00170 }
    00171 #endif
    00172
    00188 #define CS_HEADER_GLOBAL(X,Y) CS_HEADER_GLOBAL_COMPOSE(X,Y)
    00189 #define CS_HEADER_GLOBAL_COMPOSE(X,Y) <X/Y>
    00190
    00203 #define CS_HEADER_LOCAL(X,Y) CS_HEADER_LOCAL_COMPOSE1(X,Y)
    00204 #define CS_HEADER_LOCAL_COMPOSE1(X,Y) CS_HEADER_LOCAL_COMPOSE2(X/Y)
    00205 #define CS_HEADER_LOCAL_COMPOSE2(X) #X
    00206
    00207
    00213 #if !defined(CS_EXPORTED_FUNCTION)
    00214 #  if defined(CS_STATIC_LINKED)
    00215 #    define CS_EXPORTED_FUNCTION extern "C"
    00216 #  else
    00217 #    define CS_EXPORTED_FUNCTION extern "C" CS_EXPORT_SYM_DLL
    00218 #  endif
    00219 #endif
    00220
    00232 #if !defined(CS_EXPORTED_NAME)
    00233 #  define CS_EXPORTED_NAME(Prefix, Suffix) Prefix ## Suffix
    00234 #endif
    00235
    00236 #ifndef CS_IMPLEMENT_PLATFORM_PLUGIN
    00237 #  define CS_IMPLEMENT_PLATFORM_PLUGIN
    00238 #endif
    00239
    00240 #ifndef CS_IMPLEMENT_PLATFORM_APPLICATION
    00241 #  define CS_IMPLEMENT_PLATFORM_APPLICATION
    00242 #endif
    00243
    00250 #ifndef CS_INITIALIZE_PLATFORM_APPLICATION
    00251 #  define CS_INITIALIZE_PLATFORM_APPLICATION /* */
    00252 /*
    00253   This definition may seem odd, but it's here for doxygen's sake, which
    00254   apparently fails to document empty macro definitions.
    00255  */
    00256 #endif
    00257
    00258 typedef void (*csStaticVarCleanupFN) (void (*p)());
    00259 extern csStaticVarCleanupFN csStaticVarCleanup;
    00260
    00261 #ifndef CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION
    00262 #  define CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION(Name)              \
    00263 void Name (void (*p)())                                                \
    00264 {                                                                      \
    00265   static void (**a)() = 0;                                             \
    00266   static int lastEntry = 0;                                            \
    00267   static int maxEntries = 0;                                           \
    00268                                                                        \
    00269   if (p != 0)                                                          \
    00270   {                                                                    \
    00271     if (lastEntry >= maxEntries)                                       \
    00272     {                                                                  \
    00273       maxEntries += 10;                                                \
    00274       if (a == 0)                                                      \
    00275         a = (void (**)())malloc(maxEntries * sizeof(void*));           \
    00276       else                                                             \
    00277         a = (void (**)())realloc(a, maxEntries * sizeof(void*));       \
    00278     }                                                                  \
    00279     a[lastEntry++] = p;                                                \
    00280   }                                                                    \
    00281   else if (a != 0)                                                     \
    00282   {                                                                    \
    00283     for (int i = lastEntry - 1; i >= 0; i--)                           \
    00284       a[i] ();                                                         \
    00285     free (a);                                                          \
    00286     a = 0;                                                             \
    00287     lastEntry = 0;                                                     \
    00288     maxEntries = 0;                                                    \
    00289   }                                                                    \
    00290 }
    00291 #endif
    00292
    00293 #ifndef CS_DEFINE_STATIC_VARIABLE_REGISTRATION
    00294 #  define CS_DEFINE_STATIC_VARIABLE_REGISTRATION(func) \
    00295     csStaticVarCleanupFN csStaticVarCleanup = &func
    00296 #endif
    00297
    00298 #ifndef CS_DECLARE_STATIC_VARIABLE_REGISTRATION
    00299 #  define CS_DECLARE_STATIC_VARIABLE_REGISTRATION(func) \
    00300     void func (void (*p)())
    00301 #endif
    00302
    00303 #ifndef CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION
    00304 #  define CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION               \
    00305     CS_CRYSTALSPACE_EXPORT                                              \
    00306     CS_DECLARE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);
    00307 #endif
    00308
    00309 /* scfStaticallyLinked - Flag indicating whether external linkage was used when
    00310  * building the application. Determines whether SCF scans for plugins at
    00311  * startup.
    00312  */
    00316 #if defined(CS_BUILD_SHARED_LIBS)
    00317 #  define CS_DEFINE_STATICALLY_LINKED_FLAG
    00318 #elif defined(CS_STATIC_LINKED)
    00319 #  define CS_DEFINE_STATICALLY_LINKED_FLAG  bool scfStaticallyLinked = true;
    00320 #else
    00321 #  define CS_DEFINE_STATICALLY_LINKED_FLAG  bool scfStaticallyLinked = false;
    00322 #endif
    00323
    00324
    00344 #ifndef CS_IMPLEMENT_FOREIGN_DLL
    00345 #  if defined(CS_BUILD_SHARED_LIBS)
    00346 #    define CS_IMPLEMENT_FOREIGN_DLL                                        \
    00347        CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION(csStaticVarCleanup_local); \
    00348        CS_DEFINE_STATICALLY_LINKED_FLAG                                     \
    00349        CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_local);
    00350 #  else
    00351 #    define CS_IMPLEMENT_FOREIGN_DLL                                        \
    00352        CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION                      \
    00353        CS_DEFINE_STATICALLY_LINKED_FLAG                                     \
    00354        CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);
    00355 #  endif
    00356 #endif
    00357
    00366 #if defined(CS_STATIC_LINKED)
    00367
    00368 #  ifndef CS_IMPLEMENT_PLUGIN
    00369 #  define CS_IMPLEMENT_PLUGIN                                           \
    00370           CS_IMPLEMENT_PLATFORM_PLUGIN
    00371 #  endif
    00372
    00373 #elif !defined(CS_BUILD_SHARED_LIBS)
    00374
    00375 #  ifndef CS_IMPLEMENT_PLUGIN
    00376 #  define CS_IMPLEMENT_PLUGIN                                           \
    00377           CS_IMPLEMENT_PLATFORM_PLUGIN                                  \
    00378           CS_DEFINE_STATICALLY_LINKED_FLAG                              \
    00379           CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION               \
    00380           CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);
    00381 #  endif
    00382
    00383 #else
    00384
    00385 #  ifndef CS_IMPLEMENT_PLUGIN
    00386 #  define CS_IMPLEMENT_PLUGIN                                           \
    00387    CS_DEFINE_STATICALLY_LINKED_FLAG                                     \
    00388    CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION(csStaticVarCleanup_local)  \
    00389    CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_local);   \
    00390    CS_IMPLEMENT_PLATFORM_PLUGIN
    00391 #  endif
    00392
    00393 #endif
    00394
    00403 #ifndef CS_IMPLEMENT_APPLICATION
    00404 #  define CS_IMPLEMENT_APPLICATION                                      \
    00405   CS_DECLARE_DEFAULT_STATIC_VARIABLE_REGISTRATION                       \
    00406   CS_DEFINE_STATICALLY_LINKED_FLAG                                      \
    00407   CS_DEFINE_STATIC_VARIABLE_REGISTRATION (csStaticVarCleanup_csutil);   \
    00408   CS_IMPLEMENT_PLATFORM_APPLICATION
    00409 #endif
    00410
    00414 #ifndef CS_REGISTER_STATIC_FOR_DESTRUCTION
    00415 #define CS_REGISTER_STATIC_FOR_DESTRUCTION(getterFunc)\
    00416         csStaticVarCleanup (getterFunc);
    00417 #endif
    00418
    00422 #ifndef CS_STATIC_VARIABLE_CLEANUP
    00423 #define CS_STATIC_VARIABLE_CLEANUP  \
    00424         csStaticVarCleanup (0);
    00425 #endif
    00426
    00439 #ifndef CS_IMPLEMENT_STATIC_VAR_EXT
    00440 #define CS_IMPLEMENT_STATIC_VAR_EXT(getterFunc,Type,initParam,kill_how) \
    00441 extern "C" {                                                            \
    00442 static Type *getterFunc ## _v=0;                                        \
    00443 static Type* getterFunc ();                                             \
    00444 static void getterFunc ## _kill ();                                     \
    00445 static void getterFunc ## _kill_array ();                               \
    00446 void getterFunc ## _kill ()                                             \
    00447 {                                                                       \
    00448   (void)(&getterFunc ## _kill_array);                                   \
    00449   delete getterFunc ## _v;                                              \
    00450   getterFunc ## _v = 0;                                                 \
    00451 }                                                                       \
    00452 void getterFunc ## _kill_array ()                                       \
    00453 {                                                                       \
    00454   (void)(&getterFunc ## _kill);                                         \
    00455   delete [] getterFunc ## _v;                                           \
    00456   getterFunc ## _v = 0;                                                 \
    00457 }                                                                       \
    00458 Type* getterFunc ()                                                     \
    00459 {                                                                       \
    00460   if (!getterFunc ## _v)                                                \
    00461   {                                                                     \
    00462     getterFunc ## _v = new Type initParam;                              \
    00463     csStaticVarCleanup (getterFunc ## kill_how);                        \
    00464   }                                                                     \
    00465   return getterFunc ## _v;                                              \
    00466 }                                                                       \
    00467 }
    00468 #endif
    00469
    00470 #ifndef CS_IMPLEMENT_STATIC_VAR
    00471 #define CS_IMPLEMENT_STATIC_VAR(getterFunc,Type,initParam) \
    00472  CS_IMPLEMENT_STATIC_VAR_EXT(getterFunc,Type,initParam,_kill)
    00473 #endif
    00474
    00475 #ifndef CS_IMPLEMENT_STATIC_VAR_ARRAY
    00476 #define CS_IMPLEMENT_STATIC_VAR_ARRAY(getterFunc,Type,initParam) \
    00477  CS_IMPLEMENT_STATIC_VAR_EXT(getterFunc,Type,initParam,_kill_array)
    00478 #endif
    00479
    00487 #ifndef CS_DECLARE_STATIC_CLASSVAR
    00488 #define CS_DECLARE_STATIC_CLASSVAR(var,getterFunc,Type)       \
    00489 static Type *var;                                             \
    00490 static Type *getterFunc ();
    00491 #endif
    00492
    00493 #ifndef CS_DECLARE_STATIC_CLASSVAR_REF
    00494 #define CS_DECLARE_STATIC_CLASSVAR_REF(var,getterFunc,Type)   \
    00495 static Type *var;                                             \
    00496 static Type &getterFunc ();
    00497 #endif
    00498
    00509 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_EXT
    00510 #define CS_IMPLEMENT_STATIC_CLASSVAR_EXT(Class,var,getterFunc,Type,initParam,\
    00511   kill_how)                                                     \
    00512 Type *Class::var = 0;                                           \
    00513 extern "C" {                                                    \
    00514 static void Class ## _ ## getterFunc ## _kill ();               \
    00515 static void Class ## _ ## getterFunc ## _kill_array ();         \
    00516 void Class ## _ ## getterFunc ## _kill ()                       \
    00517 {                                                               \
    00518   delete Class::getterFunc ();                                  \
    00519   (void)(&Class ## _ ## getterFunc ## _kill_array);             \
    00520 }                                                               \
    00521 void Class ## _ ## getterFunc ## _kill_array ()                 \
    00522 {                                                               \
    00523   delete [] Class::getterFunc ();                               \
    00524   (void)(&Class ## _ ## getterFunc ## _kill);                   \
    00525 }                                                               \
    00526 }                                                               \
    00527 Type* Class::getterFunc ()                                      \
    00528 {                                                               \
    00529   if (!var)                                                     \
    00530   {                                                             \
    00531     var = new Type initParam;                                   \
    00532     csStaticVarCleanup (Class ## _ ## getterFunc ## kill_how);  \
    00533   }                                                             \
    00534   return var;                                                   \
    00535 }
    00536 #endif
    00537
    00538 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR
    00539 #define CS_IMPLEMENT_STATIC_CLASSVAR(Class,var,getterFunc,Type,initParam) \
    00540   CS_IMPLEMENT_STATIC_CLASSVAR_EXT(Class,var,getterFunc,Type,initParam,_kill)
    00541 #endif
    00542
    00543 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_ARRAY
    00544 #define CS_IMPLEMENT_STATIC_CLASSVAR_ARRAY(Class,var,getterFunc,Type,\
    00545   initParam) \
    00546   CS_IMPLEMENT_STATIC_CLASSVAR_EXT(Class,var,getterFunc,Type,initParam,\
    00547     _kill_array)
    00548 #endif
    00549
    00550 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT
    00551 #define CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT(Class,var,getterFunc,Type,\
    00552   initParam,kill_how) \
    00553 Type *Class::var = 0;                                          \
    00554 extern "C" {                                                   \
    00555 static void Class ## _ ## getterFunc ## _kill ();              \
    00556 static void Class ## _ ## getterFunc ## _kill_array ();        \
    00557 void Class ## _ ## getterFunc ## _kill ()                      \
    00558 {                                                              \
    00559   (void) &Class ## _ ## getterFunc ## _kill_array;              \
    00560   delete &Class::getterFunc ();                                \
    00561 }                                                              \
    00562 void Class ## _ ## getterFunc ## _kill_array ()                \
    00563 {                                                              \
    00564   (void) &Class ## _ ## getterFunc ## _kill;                    \
    00565   delete [] &Class::getterFunc ();                             \
    00566 }                                                              \
    00567 }                                                              \
    00568 Type &Class::getterFunc ()                                     \
    00569 {                                                              \
    00570   if (!var)                                                    \
    00571   {                                                            \
    00572     var = new Type initParam;                                  \
    00573     csStaticVarCleanup (Class ## _ ## getterFunc ## kill_how); \
    00574   }                                                            \
    00575   return *var;                                                 \
    00576 }
    00577 #endif
    00578
    00579 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_REF
    00580 #define CS_IMPLEMENT_STATIC_CLASSVAR_REF(Class,var,getterFunc,Type,initParam)\
    00581   CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT(Class,var,getterFunc,Type,\
    00582     initParam,_kill)
    00583 #endif
    00584
    00585 #ifndef CS_IMPLEMENT_STATIC_CLASSVAR_REF_ARRAY
    00586 #define CS_IMPLEMENT_STATIC_CLASSVAR_REF_ARRAY(Class,var,getterFunc,Type,\
    00587   initParam) \
    00588   CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT(Class,var,getterFunc,Type,initParam,\
    00589     _kill_array)
    00590 #endif
    00591
    00592 // The following define should only be enabled if you have defined
    00593 // a special version of overloaded new that accepts two additional
    00594 // parameters: a (void*) pointing to the filename and an int with the
    00595 // line number. This is typically used for memory debugging.
    00596 // In csutil/memdebug.cpp there is a memory debugger which can (optionally)
    00597 // use this feature. Note that if CS_EXTENSIVE_MEMDEBUG is enabled while
    00598 // the memory debugger is not the memory debugger will still provide the
    00599 // needed overloaded operators so you can leave CS_EXTENSIVE_MEMDEBUG on in
    00600 // that case and the only overhead will be a little more arguments to 'new'.
    00601 // Do not enable CS_EXTENSIVE_MEMDEBUG if your platform or your own code
    00602 // defines its own 'new' operator, since this version will interfere with your
    00603 // own.
    00604 // CS_MEMORY_TRACKER is treated like CS_EXTENSIVE_MEMDEBUG here.
    00605 // Same for CS_REF_TRACKER.
    00606 #ifndef CS_DEBUG
    00607 #  undef CS_EXTENSIVE_MEMDEBUG
    00608 #  undef CS_REF_TRACKER
    00609 #else
    00610 #  if defined(CS_EXTENSIVE_MEMDEBUG) && defined(CS_MEMORY_TRACKER)
    00611 #    error Do not use CS_EXTENSIVE_MEMDEBUG and CS_MEMORY_TRACKER together!
    00612 #  endif
    00613 #endif
    00614 #if defined(CS_EXTENSIVE_MEMDEBUG) || defined(CS_MEMORY_TRACKER)
    00615 extern void* operator new (size_t s, void* filename, int line);
    00616 extern void* operator new[] (size_t s, void* filename, int line);
    00617 #define CS_EXTENSIVE_MEMDEBUG_NEW new ((void*)__FILE__, __LINE__)
    00618 #define new CS_EXTENSIVE_MEMDEBUG_NEW
    00619 #endif
    00620
    00621 #ifdef CS_DEBUG
    00622 #  if !defined (CS_DEBUG_BREAK)
    00623 #    if defined (CS_PLATFORM_WIN32)
    00624 #      define CS_DEBUG_BREAK ::DebugBreak()
    00625 #    elif defined (CS_PROCESSOR_X86)
    00626 #      if defined (CS_COMPILER_GCC)
    00627 #        define CS_DEBUG_BREAK asm ("int $3")
    00628 #      else
    00629 #        define CS_DEBUG_BREAK _asm int 3
    00630 #      endif
    00631 #    else
    00632 #      define CS_DEBUG_BREAK { static int x = 0; x /= x; }
    00633 #    endif
    00634 #  endif
    00635 #  if !defined (CS_ASSERT_MSG)
    00636     namespace CrystalSpace
    00637     {
    00638       namespace Debug
    00639       {
    00640         extern void AssertMessage (const char* expr, const char* filename,
    00641           int line, const char* msg = 0);
    00642       } // namespace Debug
    00643     } // namespace CrystalSpace
    00644 #   define CS_ASSERT_MSG(msg,x)                                         \
    00645       if (!(x)) CrystalSpace::Debug::AssertMessage (#x, __FILE__, __LINE__, msg);
    00646 #  endif
    00647 #  if !defined (CS_ASSERT)
    00648 #    define CS_ASSERT(x)        CS_ASSERT_MSG(0, x)
    00649 #  endif
    00650 #else
    00651 #  undef  CS_DEBUG_BREAK
    00652 #  define CS_DEBUG_BREAK
    00653 #  undef  CS_ASSERT
    00654 #  define CS_ASSERT(x)          (void)0
    00655 #  undef  CS_ASSERT_MSG
    00656 #  define CS_ASSERT_MSG(m,x)    (void)0
    00657 #endif
    00658
    00685 #if !defined(CS_DEPRECATED_METHOD) || defined(DOXYGEN_RUN)
    00686 #  if defined(CS_COMPILER_MSVC)
    00687 #    define CS_DEPRECATED_METHOD                /*__declspec(deprecated)*/
    00688       /* Disabled: Unfortunately, MSVC is overzealous with warnings;
    00689          it even emits one when a deprecated method is overridden, e.g. when
    00690          implementing an interface method. */
    00691 #  else
    00692 #    define CS_DEPRECATED_METHOD
    00693 #  endif
    00694 #endif
    00695
    00705 #if !defined(CS_DEPRECATED_TYPE) || defined(DOXYGEN_RUN)
    00706 #  if defined(CS_COMPILER_MSVC)
    00707 #    define CS_DEPRECATED_TYPE
    00708 #  else
    00709 #    define CS_DEPRECATED_TYPE
    00710 #  endif
    00711 #endif
    00712
    00724 #if !defined(CS_CONST_METHOD) || defined(DOXYGEN_RUN)
    00725 #define CS_CONST_METHOD
    00726 #endif
    00727
    00740 #if !defined(CS_PURE_METHOD) || defined(DOXYGEN_RUN)
    00741 #define CS_PURE_METHOD
    00742 #endif
    00743
    00744 // Check if the csosdefs.h defined either CS_LITTLE_ENDIAN or CS_BIG_ENDIAN
    00745 #if !defined (CS_LITTLE_ENDIAN) && !defined (CS_BIG_ENDIAN)
    00746 #  error No CS_XXX_ENDIAN macro defined in your OS-specific csosdefs.h!
    00747 #endif
    00748
    00749 /*
    00750  * This is a bit of overkill but if you're sure your CPU doesn't require
    00751  * strict alignment add your CPU to the !defined below to get slightly
    00752  * smaller and faster code in some cases.
    00753  *
    00754  * @@@ In the future, this should be moved to csconfig.h and determined as
    00755  * part of the configuration process.
    00756  */
    00757 #if !defined (CS_PROCESSOR_X86)
    00758 #  define CS_STRICT_ALIGNMENT
    00759 #endif
    00760
    00761 // Adjust some definitions contained in csconfig.h
    00762 #if !defined (CS_PROCESSOR_X86) || !defined (CS_HAVE_NASM)
    00763 #  undef CS_HAVE_MMX
    00764 #  undef CS_HAVE_NASM
    00765 #endif
    00766
    00767 // Use special knowledge of IEEE float format in some cases for CPU's that are
    00768 // known to support it
    00769 #if !defined (CS_IEEE_DOUBLE_FORMAT)
    00770 #  if defined (CS_PROCESSOR_X86) || \
    00771       defined (CS_PROCESSOR_POWERPC) || \
    00772       defined (CS_PROCESSOR_M68K)
    00773 #    define CS_IEEE_DOUBLE_FORMAT
    00774 #  endif
    00775 #endif
    00776
    00777 // gcc can perform usefull checking for printf/scanf format strings, just add
    00778 // this define at the end of the function declaration
    00779 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
    00780 #  define CS_GNUC_PRINTF(format_idx, arg_idx) \
    00781      __attribute__((format (__printf__, format_idx, arg_idx)))
    00782 #  define CS_GNUC_SCANF(format_idx, arg_idx) \
    00783      __attribute__((format (__scanf__, format_idx, arg_idx)))
    00784 #else
    00785 #  define CS_GNUC_PRINTF(format_idx, arg_idx)
    00786 #  define CS_GNUC_SCANF(format_idx, arg_idx)
    00787 #endif
    00788
    00789 // Remove __attribute__ on non GNUC compilers.
    00790 #ifndef __GNUC__
    00791 #define __attribute__(x)
    00792 #endif
    00793
    00794 // Support for alignment and packing of structures.
    00795 #if !defined(CS_STRUCT_ALIGN_4BYTE_BEGIN)
    00796 #  if defined(__GNUC__) && defined(CS_STRICT_ALIGNMENT)
    00797 #    define CS_STRUCT_ALIGN_4BYTE_BEGIN
    00798 #    define CS_STRUCT_ALIGN_4BYTE_END __attribute__ ((aligned(4)))
    00799 #  else
    00800 #    define CS_STRUCT_ALIGN_4BYTE_BEGIN
    00801 #    define CS_STRUCT_ALIGN_4BYTE_END
    00802 #  endif
    00803 #endif
    00804
    00805 #if defined(CS_COMPILER_MSVC)
    00806   #define CS_ALIGNED_MEMBER(Member, Align)                              \
    00807     __declspec(align(Align)) Member
    00808 #elif defined(CS_COMPILER_GCC)
    00809
    00821   #define CS_ALIGNED_MEMBER(Member, Align)                              \
    00822     Member __attribute((aligned(Align)))
    00823 #else
    00824   #define CS_ALIGNED_MEMBER(Member, Align)      Member
    00825 #endif
    00826
    00827 // Macro used to define static implicit pointer conversion function.
    00828 // Only use within a class declaration.
    00829 #ifndef _CS_IMPLICITPTRCAST_NAME
    00830 #  define _CS_IMPLICITPTRCAST_NAME __ImplicitPtrCast
    00831 #endif
    00832
    00854 #define CS_IMPLEMENT_IMPLICIT_PTR_CAST(classname) \
    00855   inline static classname* _CS_IMPLICITPTRCAST_NAME (classname* ptr) \
    00856   { \
    00857     return ptr;\
    00858   }
    00859
    00868 #define CS_IMPLICIT_PTR_CAST(classname, ptr) \
    00869   (classname::_CS_IMPLICITPTRCAST_NAME(ptr))
    00870
    00874 #ifdef CS_HAVE_VA_COPY
    00875 #  define CS_VA_COPY(dest, src)         va_copy(dest, src)
    00876 #else
    00877 #  ifdef CS_HAVE___VA_COPY
    00878 #    define CS_VA_COPY(dest, src)       __va_copy(dest, src)
    00879 #  else
    00880 #    define CS_VA_COPY(dest, src)       dest = src;
    00881 #  endif
    00882 #endif
    00883
    00888 #if defined(CS_COMPILER_GCC)
    00889 #  define CS_FUNCTION_NAME              __PRETTY_FUNCTION__
    00890 #elif defined(__FUNCTION__)
    00891 #  define CS_FUNCTION_NAME              __FUNCTION__
    00892 #else
    00893 #  define CS_FUNCTION_NAME              "<?\?\?>"
    00894 #endif
    00895
    00896 #define CS_STRING_TO_WIDE_(x)   L ## x
    00897
    00904 #define CS_STRING_TO_WIDE(x)    CS_STRING_TO_WIDE_(x)
    00905
    00906 #endif // __CS_CSSYSDEF_H__