/simpletypesystem/trunk

/*

*/

#ifndef __H_DEFS__

#define __H_DEFS__

#include <limits.h>

#include <stddef.h>

#include <uchar.h>

#include <stdint.h>

#include <inttypes.h>

#include <assert.h>

/** @file

 * @defgroup Definitions Definitions

 * @addtogroup Definitions

 * @{

 */

/**

 * BEGIN_DECLS

 * For interoperabibily with C++ we have to have this.

 *

 * Put at the beginning and end of headerfiles.

 */

#ifdef __cplusplus

#define BEGIN_DECLS extern "C" {

#define END_DECLS }

#else

#define BEGIN_DECLS

#define END_DECLS

#endif /*__cplusplus*/

#if defined(__GNUC__)

#define DEPRECATED __attribute__((deprecated))

#define UNUSED __attribute__((unused))

#define ALIGNED_8 __attribute__((aligned (8)))

#define ALIGNED_16 __attribute__((aligned (16)))

#elif __MSC_VER

#define DEPRECATED __declspec(deprecated)

// TODO, check if this rely works in MSVC.

#define UNUSED __pragma(warning(suppress:4100))

#define ALIGNED_8 __declspec(align(8))

#define ALIGNED_16 __declspec(align(16))

#else

#define DEPRECATED

#define UNUSED

#define ALIGNED_8

#define ALIGNED_16

#endif

BEGIN_DECLS

#include <stdio.h>

#include <stdlib.h>

/**

 * FALSE has the absolute value of 0, it is used in as a way to represet a false

 * value. A "not" value.

 */

#define FALSE 0

 /**

  * TRUE represets a value that is true. A value that is "not false".

  */

#define TRUE (!FALSE)

#define S_POINTER_TO_HASH_T(p) ((hash_t)(unsigned long) p)

/**

 * @defgroup Types Type declarations

 * @addtogroup Types

 * @{

 */

/**

 * sboolean is the standard definition of a boolean value in SSTS.

 *

 * @sa TRUE

 * @sa FALSE

 *

 * @note

 * This is the way it is done in GLib, so it is done here too.

 */

typedef int sboolean;

/** hash type  */

typedef size_t hash_t;

/** spointer is a convinience typedef of void * */

typedef void* spointer;

/** sconstpointer is a convinience typedef of const void * */

typedef const void* sconstpointer;

/**

 * To prevent intercomatability problems we def schar and assert its size.

 */

typedef char schar;

static_assert (sizeof(schar) == sizeof (int8_t),

              "schar has the wrong size. Is not 8 bit long.");

/**

 * uchar is the representation for use with wide unicode strings and what not.

 * 

 * The rationell for using char32_t as the unicode wide char instead of

 * wchar_t is that wchar_t's size depends on the imprementation, compiler,

 * and system.

 *

 * To make the wide strings actually work as they should, even over network or

 * other communication we set this as the standard for the uchar.

 */

typedef char32_t suchar;

/**

 * To prevent intercomatability problems we def long as int64_t.

 */

typedef int64_t slong;

/**

 * To prevent intercomatability problems we def int as int32_t.

 */

typedef int32_t sint;

/**

 * To prevent intercomatability problems we def short as int16_t.

 */

typedef int16_t sshort;

/**

 * To prevent intercomatability problems we def byte as int8_t.

 */

typedef int8_t sbyte;

/* *************************************

   ******* UNSIGNED VERSIONS ***********

   ************************************* */

/**

 * To prevent intercomatability problems we def ulong as uint64_t.

 */

typedef uint64_t sulong;

/**

 * To prevent intercomatability problems we def uint as uint32_t.

 */

typedef uint32_t suint;

/**

 * To prevent intercomatability problems we def ushort as uint16_t.

 */

typedef uint16_t sushort;

/**

 * To prevent intercomatability problems we def ubyte as uint8_t.

 */

typedef uint8_t subyte;

/* *********** FLOATS **************** */

typedef float sfloat;

static_assert (sizeof (sfloat) == sizeof (int8_t) * 4,

              "sfloat has the wrong size. Is not 32 bit.");

typedef double sdouble;

static_assert (sizeof (sdouble) == sizeof (int8_t) * 8,

              "sdouble has the wrong size. Is not 64 bit.");

typedef __float128 squadruple;

static_assert (sizeof (squadruple) == sizeof (int8_t) * 16,

              "squadruple has the wrong size. Is not 128 bit.");

/**

 * @}

 */

/**

 * Represents different types of objects.

 *

 * @se STypeName

 */

typedef enum {

  S_TYPE_NONE = 0,

  S_TYPE_INT,

  S_TYPE_LONG,

  S_TYPE_SHORT,

  S_TYPE_CHAR,

  S_TYPE_WCHAR,

  S_TYPE_UCHAR, /**< char32_t/uchar */

  S_TYPE_UINT,

  S_TYPE_ULONG,

  S_TYPE_USHORT,

  S_TYPE_BOOLEAN,

  S_TYPE_STRING,

  S_TYPE_WSTRING, /**< Plarform specific wchar_t */

  S_TYPE_USTRING, /**< char32_t String.*/

  S_TYPE_UNUSED_0,

  S_TYPE_UNUSED_1,

  S_TYPE_UNUSED_2,

  S_TYPE_POINTER,

  S_TYPE_OBJECT,

  S_TYPE_INVALID

} SType;

/** @brief

 * The names of the SType's

 *

 * 

 */

static char * STypeName[] UNUSED = {

  "NONE",

  "INT",

  "LONG",

  "SHORT",

  "CHAR",

  "WCHAR",

  "UCHAR", /*< char32_t */

  "UINT",

  "ULONG",

  "USHORT"

  "BOOLEAN",

  "STRING",

  "WSTRING",

  "USTRING",

  "UNUSED_0/INVALID",

  "UNUSED_1/INVALID",

  "UNUSED_2/INVALID",

  "POINTER",

  "OBJECT",

  "INVALID",

  0x0,

  0x0,

};

/**

 * @brief Get the name of the SType.

 *

 * For use in bindings.

 */

char *

s_type_get_name (SType k);

/* Colour definitions for console prints */

#define RESET   "\033[0m"

#define BLACK   "\033[30m"      /* Black */

#define RED     "\033[31m"      /* Red */

#define GREEN   "\033[32m"      /* Green */

#define YELLOW  "\033[33m"      /* Yellow */

#define BLUE    "\033[34m"      /* Blue */

#define MAGENTA "\033[35m"      /* Magenta */

#define CYAN    "\033[36m"      /* Cyan */

#define WHITE   "\033[37m"      /* White */

#define BOLDBLACK   "\033[1m\033[30m"      /* Bold Black */

#define BOLDRED     "\033[1m\033[31m"      /* Bold Red */

#define BOLDGREEN   "\033[1m\033[32m"      /* Bold Green */

#define BOLDYELLOW  "\033[1m\033[33m"      /* Bold Yellow */

#define BOLDBLUE    "\033[1m\033[34m"      /* Bold Blue */

#define BOLDMAGENTA "\033[1m\033[35m"      /* Bold Magenta */

#define BOLDCYAN    "\033[1m\033[36m"      /* Bold Cyan */

#define BOLDWHITE   "\033[1m\033[37m"      /* Bold White */

/**

 * @}

 */

END_DECLS

#endif