CrystalSpace

Public API Reference

Main Page   Modules   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

cssysdef.h File Reference

This include file should be included from every source file. More...

#include "csdef.h"
#include "csutil/csosdefs.h"
#include "csextern.h"
#include <malloc.h>
#include <unistd.h>
#include "csutil/getopt.h"
#include <sys/select.h>

Go to the source code of this file.

Defines

#define CS_ALLOC_STACK_ARRAY(type, var, size)   type *var = (type *)alloca ((size) * sizeof (type))
 Dynamic stack memory allocation.

#define TEMP_DIR   ""
 Directory for temporary files.

#define TEMP_FILE   "$cs$.tmp"
 Name for temporary file.

#define MKDIR(path)   mkdir (path, 0755)
 How to make a directory (not entire path, only the last on the path).

#define CS_HEADER_GLOBAL(X, Y)   CS_HEADER_GLOBAL_COMPOSE(X,Y)
 The CS_HEADER_GLOBAL() macro composes a pathname from two components and wraps the path in `<' and `>'.

#define CS_HEADER_LOCAL(X, Y)   CS_HEADER_LOCAL_COMPOSE1(X,Y)
 The CS_HEADER_LOCAL() macro composes a pathname from two components and wraps the path in double-quotes.

#define CS_INITIALIZE_PLATFORM_APPLICATION
 Perform platform-specific application initializations.

#define CS_IMPLEMENT_PLUGIN
 The CS_IMPLEMENT_PLUGIN macro should be placed at the global scope in exactly one compilation unit comprising a plugin module.

#define CS_IMPLEMENT_APPLICATION
 The CS_IMPLEMENT_APPLICATION macro should be placed at the global scope in exactly one compilation unit comprising an application.

#define CS_REGISTER_STATIC_FOR_DESTRUCTION(getterFunc)   CS_STATIC_VAR_DESTRUCTION_REGISTRAR_FUNCTION (getterFunc);
 Register a method that will destruct one static variable.

#define CS_STATIC_VARIABLE_CLEANUP   CS_STATIC_VAR_DESTRUCTION_REGISTRAR_FUNCTION (0);
 Invoke the function that will call all destruction functions.

#define CS_IMPLEMENT_STATIC_VAR(getterFunc, Type, initParam)   CS_IMPLEMENT_STATIC_VAR_EXT(getterFunc,Type,initParam,_kill)
 Create a global variable thats created on demand.

#define CS_DECLARE_STATIC_CLASSVAR(var, getterFunc, Type)
 Declare a static variable inside a class.

#define CS_IMPLEMENT_STATIC_CLASSVAR(Class, var, getterFunc, Type, initParam)   CS_IMPLEMENT_STATIC_CLASSVAR_EXT(Class,var,getterFunc,Type,initParam,_kill)
 Create the static class variable that has been declared with CS_DECLARE_STATIC_CLASSVAR.

#define CS_IMPLEMENT_IMPLICIT_PTR_CAST(classname)
 Implements a static member function for a class which can be used to perform implicit pointer casts.

#define CS_IMPLICIT_PTR_CAST(classname, ptr)   (classname::_CS_IMPLICITPTRCAST_NAME(ptr))
 Perform a compiler implicit cast of a pointer to another pointer type using a static member function declared with the CS_IMPLEMENT_IMPLICIT_PTR_CAST macro.


Variables

void(* fatal_exit )(int errorcode, bool canreturn)
 Fatal exit routine (which can be replaced if neccessary).


Detailed Description

This include file should be included from every source file.

Just before include directive it can contain several define's that specify what the source file requires.

The following variables can be defined:

define CS_SYSDEF_PROVIDE_MKDIR Include definition for MKDIR()

define CS_SYSDEF_PROVIDE_GETCWD Include definition for getcwd()

define CS_SYSDEF_PROVIDE_TEMP Include definitions for TEMP_DIR and TEMP_FILE.

define CS_SYSDEF_PROVIDE_DIR Include definitions required for opendir(), readdir(), closedir() and isdir().

define CS_SYSDEF_PROVIDE_UNLINK Include definitions required for unlink()

define CS_SYSDEF_PROVIDE_ACCESS Include definitions required for access()

define CS_SYSDEF_PROVIDE_GETOPT For getopt() and GNU getopt_long()

define CS_SYSDEF_PROVIDE_SELECT Includes definitions required for select(), FD_* macros, and struct timeval.

The system-dependent include files can undefine some or all CS_SYSDEF_PROVIDE_xxx macros to avoid further definitions in this file. For example, if a system-dependent file defines everything needed for CS_SYSDEF_PROVIDE_GETOPT it should undefine CS_SYSDEF_PROVIDE_GETOPT to avoid including util/gnu/getopt.h at the bottom of this file.

Definition in file cssysdef.h.


Define Documentation

#define CS_ALLOC_STACK_ARRAY type,
var,
size       type *var = (type *)alloca ((size) * sizeof (type))
 

Dynamic stack memory allocation.

Parameters:
type  Type of the array elements.
var  Name of the array to be allocated.
size  Number of elements to be allocated.

Definition at line 94 of file cssysdef.h.

#define CS_DECLARE_STATIC_CLASSVAR var,
getterFunc,
Type   
 

Value:

static Type *var;                                             \
static Type *getterFunc ();
Declare a static variable inside a class.

This will also declare a Getter function. Example: CS_DECLARE_STATIC_CLASSVAR (pool, GetVertexPool, csVertexPool)

Definition at line 478 of file cssysdef.h.

#define CS_DECLARE_STATIC_CLASSVAR_REF var,
getterFunc,
Type   
 

Value:

static Type *var;                                             \
static Type &getterFunc ();

Definition at line 484 of file cssysdef.h.

#define CS_DECLARE_STATIC_VARIABLE_REGISTRATION
 

Value:

CS_STATIC_VAR_EXTERN void \
    CS_STATIC_VAR_DESTRUCTION_REGISTRAR_FUNCTION (void (*p)());

Definition at line 314 of file cssysdef.h.

#define CS_HEADER_GLOBAL X,
     CS_HEADER_GLOBAL_COMPOSE(X,Y)
 

The CS_HEADER_GLOBAL() macro composes a pathname from two components and wraps the path in `<' and `>'.

This macro is useful in cases where one does not have the option of augmenting the preprocessor's header search path, even though the include path for some header file may vary from platform to platform. For instance, on many platforms OpenGL headers are in a `GL' directory, whereas on other platforms they are in an `OpenGL' directory. As an example, in the first case, the platform might define the preprocessor macro GLPATH with the value `GL', and in the second case GLPATH would be given the value `OpenGL'. To actually include an OpenGL header, such as gl.h, the following code would be used:

 include CS_HEADER_GLOBAL(GLPATH,gl.h)
 

Definition at line 237 of file cssysdef.h.

#define CS_HEADER_LOCAL X,
     CS_HEADER_LOCAL_COMPOSE1(X,Y)
 

The CS_HEADER_LOCAL() macro composes a pathname from two components and wraps the path in double-quotes.

This macro is useful in cases where one does not have the option of augmenting the preprocessor's header search path, even though the include path for some header file may vary from platform to platform. For example, assuming that the preprocessor macro UTILPATH is defined with some platform-specific value, to actually include a header, such as util.h, the following code would be used:

 include CS_HEADER_LOCAL(UTILPATH,util.h)
 

Definition at line 252 of file cssysdef.h.

#define CS_IMPLEMENT_APPLICATION
 

Value:

CS_IMPLEMENT_STATIC_VARIABLE_CLEANUP  \
   CS_IMPLEMENT_PLATFORM_APPLICATION
The CS_IMPLEMENT_APPLICATION macro should be placed at the global scope in exactly one compilation unit comprising an application.

For maximum portability, each application should employ this macro. Platforms may override the definition of this macro in order to augment the implementation of an application with any special implementation details required by the platform.

Definition at line 397 of file cssysdef.h.

#define CS_IMPLEMENT_IMPLICIT_PTR_CAST classname   
 

Value:

inline static classname* _CS_IMPLICITPTRCAST_NAME (classname* ptr) \
  { \
    return ptr;\
  }
Implements a static member function for a class which can be used to perform implicit pointer casts.

Parameters:
classname  Name of the class that the macro is being used in.
Remarks:
This macro is intended to support typecasting within macros, allowing the compiler to provide a more descriptive error message. Use CS_IMPLEMENT_IMPLICIT_PTR_CAST in the declaration of the class and CS_IMPLICIT_PTR_CAST in the macro declaration.
Example:
 struct iObjectRegistry : public iBase
 {
   // Allow implicit casts through static function.
   CS_IMPLEMENT_IMPLICIT_PTR_CAST(iObjectRegistry);
   ...
 }

 #define CS_QUERY_REGISTRY_TAG(Reg, Tag) \
  csPtr<iBase> (CS_IMPLICIT_PTR_CAST(iObjectRegistry, Reg)->Get (Tag))

Definition at line 736 of file cssysdef.h.

#define CS_IMPLEMENT_PLUGIN
 

Value:

CS_IMPLEMENT_STATIC_VARIABLE_CLEANUP    \
   CS_IMPLEMENT_PLATFORM_PLUGIN
The CS_IMPLEMENT_PLUGIN macro should be placed at the global scope in exactly one compilation unit comprising a plugin module.

For maximum portability, each plugin module must employ this macro. Platforms may override the definition of this macro in order to augment the implementation of the plugin module with any special implementation details required by the platform.

Definition at line 380 of file cssysdef.h.

#define CS_IMPLEMENT_STATIC_CLASSVAR Class,
var,
getterFunc,
Type,
initParam       CS_IMPLEMENT_STATIC_CLASSVAR_EXT(Class,var,getterFunc,Type,initParam,_kill)
 

Create the static class variable that has been declared with CS_DECLARE_STATIC_CLASSVAR.

This will also create the Getter function and the destruction function. The destruction function will be registered upon the first invocation of the Getter function. Example: CS_IMPLEMENT_STATIC_CLASSVAR (csPolygon2D, pool, GetVertexPool, csVertexPool,)

Definition at line 528 of file cssysdef.h.

#define CS_IMPLEMENT_STATIC_CLASSVAR_EXT Class,
var,
getterFunc,
Type,
initParam,
kill_how   
 

Value:

Type *Class::var = 0;                                                                    \
extern "C" {                                                                             \
static void Class ## _ ## getterFunc ## _kill ();                                        \
static void Class ## _ ## getterFunc ## _kill_array ();                                  \
void Class ## _ ## getterFunc ## _kill ()                                                \
{                                                                                        \
  (void) Class ## _ ## getterFunc ## _kill_array;                                        \
  delete Class::getterFunc ();                                                           \
}                                                                                        \
void Class ## _ ## getterFunc ## _kill_array ()                                          \
{                                                                                        \
  (void) Class ## _ ## getterFunc ## _kill;                                              \
  delete [] Class::getterFunc ();                                                        \
}                                                                                        \
}                                                                                        \
Type* Class::getterFunc ()                                                               \
{                                                                                        \
  if (!var)                                                                              \
  {                                                                                      \
    var = new Type initParam;                                                            \
    CS_DECLARE_STATIC_VARIABLE_REGISTRATION                                              \
    CS_REGISTER_STATIC_FOR_DESTRUCTION (Class ## _ ## getterFunc ## kill_how);           \
  }                                                                                      \
  return var;                                                                            \
}

Definition at line 499 of file cssysdef.h.

#define CS_IMPLEMENT_STATIC_CLASSVAR_REF_EXT Class,
var,
getterFunc,
Type,
initParam,
kill_how   
 

Value:

Type *Class::var = 0;                                                                        \
extern "C" {                                                                                 \
static void Class ## _ ## getterFunc ## _kill ();                                            \
static void Class ## _ ## getterFunc ## _kill_array ();                                      \
void Class ## _ ## getterFunc ## _kill ()                                                    \
{                                                                                            \
  (void) Class ## _ ## getterFunc ## _kill_array;                                            \
  delete &Class::getterFunc ();                                                              \
}                                                                                            \
void Class ## _ ## getterFunc ## _kill_array ()                                              \
{                                                                                            \
  (void) Class ## _ ## getterFunc ## _kill;                                                  \
  delete [] &Class::getterFunc ();                                                           \
}                                                                                            \
}                                                                                            \
Type &Class::getterFunc ()                                                                   \
{                                                                                            \
  if (!var)                                                                                  \
  {                                                                                          \
    var = new Type initParam;                                                                \
    CS_DECLARE_STATIC_VARIABLE_REGISTRATION                                                  \
    CS_REGISTER_STATIC_FOR_DESTRUCTION (Class ## _ ## getterFunc ## kill_how);               \
  }                                                                                          \
  return *var;                                                                               \
}

Definition at line 538 of file cssysdef.h.

#define CS_IMPLEMENT_STATIC_VAR getterFunc,
Type,
initParam       CS_IMPLEMENT_STATIC_VAR_EXT(getterFunc,Type,initParam,_kill)
 

Create a global variable thats created on demand.

Create a Getter function to access the variable and a destruction function. The Getter function will register the destruction function on first invocation. Example: CS_IMPLEMENT_STATIC_VAR (GetVertexPool, csVertexPool,) This will give you a global function GetVertexPool that returns a pointer to a static variable.

Definition at line 463 of file cssysdef.h.

#define CS_IMPLEMENT_STATIC_VAR_EXT getterFunc,
Type,
initParam,
kill_how   
 

Value:

CS_DECLARE_STATIC_VARIABLE_REGISTRATION                                 \
extern "C" {                                                            \
static Type* getterFunc ();                                             \
static void getterFunc ## _kill ();                                     \
static void getterFunc ## _kill_array ();                               \
void getterFunc ## _kill ()                                             \
{                                                                       \
  (void)getterFunc ## _kill_array;                                      \
  delete getterFunc ();                                                 \
}                                                                       \
void getterFunc ## _kill_array ()                                       \
{                                                                       \
  (void)getterFunc ## _kill;                                            \
  delete [] getterFunc ();                                              \
}                                                                       \
Type* getterFunc ()                                                     \
{                                                                       \
  static Type *v=0;                                                     \
  if (!v)                                                               \
  {                                                                     \
    v = new Type initParam;                                             \
    CS_REGISTER_STATIC_FOR_DESTRUCTION (getterFunc ## kill_how);        \
  }                                                                     \
  return v;                                                             \
}                                                                       \
}

Definition at line 433 of file cssysdef.h.

#define CS_IMPLEMENT_STATIC_VARIABLE_REGISTRATION
 

Value:

CS_STATIC_VAR_EXTERN void                                              \
CS_STATIC_VAR_DESTRUCTION_REGISTRAR_FUNCTION (void (*p)())             \
{                                                                      \
  static void (**a)() = 0;                                             \
  static int lastEntry = 0;                                            \
  static int maxEntries = 0;                                           \
                                                                       \
  if (p != 0)                                                          \
  {                                                                    \
    if (lastEntry >= maxEntries)                                       \
    {                                                                  \
      maxEntries += 10;                                                \
      if (a == 0)                                                      \
        a = (void (**)())malloc(maxEntries * sizeof(void*));           \
      else                                                             \
        a = (void (**)())realloc(a, maxEntries * sizeof(void*));       \
    }                                                                  \
    a[lastEntry++] = p;                                                \
  }                                                                    \
  else if (a != 0)                                                     \
  {                                                                    \
    for (int i = lastEntry - 1; i >= 0; i--)                           \
      a[i] ();                                                         \
    free (a);                                                          \
    a = 0;                                                             \
    lastEntry = 0;                                                     \
    maxEntries = 0;                                                    \
  }                                                                    \
}

Definition at line 325 of file cssysdef.h.

#define CS_IMPLICIT_PTR_CAST classname,
ptr       (classname::_CS_IMPLICITPTRCAST_NAME(ptr))
 

Perform a compiler implicit cast of a pointer to another pointer type using a static member function declared with the CS_IMPLEMENT_IMPLICIT_PTR_CAST macro.

Parameters:
classname  Name of the class to convert to
ptr  Pointer to be convereted into
See also:
CS_IMPLEMENT_IMPLICIT_PTR_CAST

Definition at line 750 of file cssysdef.h.

#define CS_INITIALIZE_PLATFORM_APPLICATION
 

Perform platform-specific application initializations.

This macro should be invoked very near to the "beginning" of the application.

Remarks:
NB: It is invoked in csInitializer::CreateEnvironment().

Definition at line 296 of file cssysdef.h.

#define CS_REGISTER_STATIC_FOR_DESTRUCTION getterFunc       CS_STATIC_VAR_DESTRUCTION_REGISTRAR_FUNCTION (getterFunc);
 

Register a method that will destruct one static variable.

Definition at line 410 of file cssysdef.h.

#define CS_STATIC_VARIABLE_CLEANUP   CS_STATIC_VAR_DESTRUCTION_REGISTRAR_FUNCTION (0);
 

Invoke the function that will call all destruction functions.

Definition at line 418 of file cssysdef.h.

#define MKDIR path       mkdir (path, 0755)
 

How to make a directory (not entire path, only the last on the path).

Definition at line 129 of file cssysdef.h.

#define TEMP_DIR   ""
 

Directory for temporary files.

Definition at line 106 of file cssysdef.h.

#define TEMP_FILE   "$cs$.tmp"
 

Name for temporary file.

Definition at line 116 of file cssysdef.h.


Variable Documentation

void(* fatal_exit)(int errorcode, bool canreturn)
 

Fatal exit routine (which can be replaced if neccessary).

Definition at line 754 of file cssysdef.h.


Generated for Crystal Space by doxygen 1.2.18