CeylanTypes.h

Go to the documentation of this file.

/*
 * Copyright (C) 2003-2009 Olivier Boudeville
 *
 * This file is part of the Ceylan library.
 *
 * The Ceylan library is free software: you can redistribute it and/or modify
 * it under the terms of either the GNU Lesser General Public License or
 * the GNU General Public License, as they are published by the Free Software
 * Foundation, either version 3 of these Licenses, or (at your option)
 * any later version.
 *
 * The Ceylan library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License and the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License and the GNU General Public License along with the Ceylan library.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Olivier Boudeville (olivier.boudeville@esperide.com)
 *
 */


#ifndef CEYLAN_TYPES_H_
#define CEYLAN_TYPES_H_


#include <list>     // for ListSize


// Could be used to define bound: #include <climits>


/*
 * inttypes.h is to be preferred to stdint.h, since the former is more
 * portable and includes the latter when appropriate.
 *
 * Even inttypes.h is not included here since it is not present on all
 * platforms.
 *
 * We did not want to use CEYLAN_USES_INTTYPES_H and other defines, as it
 * forces us to include beforehand CeylanConfig.h (our "config.h").
 * It was deemed not satisfactory in installed headers, because of risks of
 * name clashes.
 * However no really portable solution was available when needing to detect
 * 64bit types, thus we finally rely on CeylanConfig.h, which defines
 * _ceylan_*int*_t symbols appropriately.
 *
 * cstdint, defined in Boost (http://www.boost.org), is sadly not existing
 * yet in the C++ standard.
 *
 * On the Nintendo DS, we could use also datatypes defined in libnds.
 *
 */


/*
 * Supposedly available on all targeted platforms (thus removes the need
 * to include "CeylanConfig.h".
 * However on GNU/Linux with gcc 4.4 we have:
 * "This file requires compiler and library support for the upcoming ISO
 * C++ standard, C++0x. This support is currently experimental, and must
 * be enabled with the -std=c++0x or -std=gnu++0x compiler options."
 * #include <cstdint>
 *
 * #include <stdint.h> does not trigger it.
 *
 *
 */



#ifdef CEYLAN_USES_CONFIG_H


// If wanting to use our CeylanConfig.h, do so (our tests will not):
#include "CeylanConfig.h"       // for configure-time settings

#ifdef CEYLAN_USES_INTTYPES_H
#include <inttypes.h>           // for int8_t and others
#endif // CEYLAN_USES_INTTYPES_H


#else // CEYLAN_USES_CONFIG_H


// Otherwise suppose this one is available and use it:
#include <inttypes.h>           // for int8_t and others

#define _ceylan_int8_t int8_t
#define _ceylan_uint8_t uint8_t

#define _ceylan_int16_t int16_t
#define _ceylan_uint16_t uint16_t

#define _ceylan_int32_t int32_t
#define _ceylan_uint32_t uint32_t

#define _ceylan_int64_t int64_t
#define _ceylan_uint64_t uint64_t


#endif // CEYLAN_USES_CONFIG_H



namespace Ceylan
{


  /*
   * Links can be made between the Ceylan basic data types (ex: Sint16) and
   * the ones defined by the C language (ex: signed short) and by OpenGL
   * (ex: GLshort).
   *
   * C synonyms to data types are specified, then OpenGL ones (they all
   * start with'GL').
   *
   * For each Ceylan basic numerical datatype, its lower and higher accepted
   * values are specified. For example, if x is a Uint8, then:
   * Uint8Min <= x <= Uint8Max (hence Min and Max bounds are included).
   *
   * @note Depending on the platform and the compiler, size of C types may
   * differ. All sizes are therefore checked at compile time (see
   * CEYLAN_COMPILE_TIME_ASSERT) and at run-time (see
   * testCeylanBasicDatatypes.cc).
   *
   * @note For example, int (signed or not) is 4 bytes (32 bits) on 32-bit
   * processors, and 2 bytes (16 bits) on 16-bit processors. With 4-bit
   * processors, it will be probably a mess again.
   *
   */


  // First, integer types.



  typedef _ceylan_int8_t Sint8 ;

  extern CEYLAN_DLL Ceylan::Sint8 Sint8Min /* = -128 */  ;
  extern CEYLAN_DLL Ceylan::Sint8 Sint8Max /* =  127 */  ;



  typedef _ceylan_uint8_t Uint8 ;

  extern CEYLAN_DLL Ceylan::Uint8 Uint8Min /* =   0 */ ;
  extern CEYLAN_DLL Ceylan::Uint8 Uint8Max /* = 255 */ ;



  typedef char Byte ;

  extern CEYLAN_DLL Ceylan::Byte ByteMin /* should be -128 */ ;
  extern CEYLAN_DLL Ceylan::Byte ByteMax /* should be 127 */ ;



  typedef _ceylan_int16_t Sint16 ;

  extern CEYLAN_DLL Ceylan::Sint16 Sint16Min /* = -32768  */ ;
  extern CEYLAN_DLL Ceylan::Sint16 Sint16Max /* =  32767  */ ;



  typedef _ceylan_uint16_t Uint16 ;

  extern CEYLAN_DLL Ceylan::Uint16 Uint16Min /* =     0 */ ;
  extern CEYLAN_DLL Ceylan::Uint16 Uint16Max /* = 65535 */ ;




  typedef _ceylan_int32_t Sint32 ;


  /*
   * Actually is -2147483648 but is incremented since
   * 'this decimal constant is unsigned only in ISO C90'.
   *
   */
  extern CEYLAN_DLL Ceylan::Sint32 Sint32Min /* = -2147483648  */ ;
  extern CEYLAN_DLL Ceylan::Sint32 Sint32Max /* =  2147483647  */ ;



  typedef _ceylan_uint32_t Uint32 ;

  extern CEYLAN_DLL Ceylan::Uint32 Uint32Min /* = 0  */ ;
  extern CEYLAN_DLL Ceylan::Uint32 Uint32Max /* = 4294967295 */ ;




  typedef signed long SignedLongInteger ;

  extern CEYLAN_DLL Ceylan::SignedLongInteger SignedLongIntegerMin ;
  extern CEYLAN_DLL Ceylan::SignedLongInteger SignedLongIntegerMax ;



  typedef unsigned long UnsignedLongInteger ;

  extern CEYLAN_DLL Ceylan::UnsignedLongInteger UnsignedLongIntegerMin ;
  extern CEYLAN_DLL Ceylan::UnsignedLongInteger UnsignedLongIntegerMax ;



#ifdef CEYLAN_HAS_64_BIT_TYPE

  typedef _ceylan_uint64_t Uint64 ;


  typedef _ceylan_int64_t Sint64 ;


#else // CEYLAN_HAS_64_BIT_TYPE

#define CEYLAN_FAKES_64_BIT_TYPE

  typedef struct
  {

    Ceylan::Uint32 hi ;
    Ceylan::Uint32 lo ;

  } Uint64, Sint64 ;

#endif // CEYLAN_HAS_64_BIT_TYPE



  /*
   * From here normally Ceylan::Uint64 and Ceylan::Sint64 can be used in
   * all cases.
   *
   *
   */


  typedef float Float32 ;

  extern CEYLAN_DLL Ceylan::Float32 Float32Min /* = -3.4E-38 */ ;
  extern CEYLAN_DLL Ceylan::Float32 Float32Max /* =  3.4E38  */ ;


  typedef double Float64 ;

  extern CEYLAN_DLL Ceylan::Float64 Float64Min /* = -1.7E-308 */ ;
  extern CEYLAN_DLL Ceylan::Float64 Float64Max /* =  1.7E308  */ ;



  /*
   * Very large floating point values are not encapsulated with regard to
   * their bit widths since they depend too much on the underlying platform.
   *
   * For example, GNU/Linux IA32 thinks `long double' is 96-bits (while the
   * real number of used bits is only 80, both in processor and in memory),
   * whereas HP-UX thinks it is 128-bits, other 80, etc.
   *
   * So the largest fixed-size floating point value used by Ceylan is
   * Ceylan::Float64 (64-bits).
   *
   * One can use nevertheless (Un)SignedLongFloat, provided she does not
   * rely on any specific bit width.
   *
   */


  typedef long double LongFloat ;

  extern CEYLAN_DLL Ceylan::LongFloat LongFloatMin ;
  extern CEYLAN_DLL Ceylan::LongFloat LongFloatMax ;



  //typedef long double Float80 ;

  //extern CEYLAN_DLL Ceylan::Float80 Float80Min /* = -3.4E-4932 */ ;

  /*
   * Actually is 3.4E4932 but is set to a lower value (the highest
   * possible one) since 'floating constant exceeds range of double'.
   *
   */
  //extern CEYLAN_DLL Ceylan::Float80 Float80Max
  //    /*= 3.4E4932 in theory, 1.7E308 actually */ ;



  //typedef long double Float96 ;


  //extern CEYLAN_DLL Ceylan::Float96 Float96Min /* = -3.4E-4932 */ ;

  /*
   * Actually is 3.4E4932 but is set to a lower value (the highest
   * possible one) since 'floating constant exceeds range of double'.
   *
   */
  //extern CEYLAN_DLL Ceylan::Float96 Float96Max
  //    /*= 3.4E4932 in theory, 1.7E308 actually */ ;




  typedef Ceylan::Uint16 Count ;



  typedef std::list<Ceylan::Uint16>::size_type ListSize ;



  typedef Ceylan::Uint32 Flags ;


  /*
   * Makes sure the data types really have the right sizes, thanks to a
   * trick coming from SDL:
   * if the size of tested type does not match desired value, expression
   * 'sizeof(t)  == n' is false (0) and the macro attempts to define an
   * array of '0*2 -1' = -1 element, which results in a compilation error,
   * such as 'error: size of array
   * `CEYLAN_stop_wrong_size_for_uint64' is negative'.
   *
   * If the sizes are the expected ones, all arrays have exactly one element
   * and the compiler does not complain.
   *
   */
#define CEYLAN_COMPILE_TIME_ASSERT(name, x)                     \
  typedef int CEYLAN_stop_wrong_size_for_ ## name[(x) * 2 - 1]

  CEYLAN_COMPILE_TIME_ASSERT( uint8,   sizeof(Uint8)   == 1  ) ;
  CEYLAN_COMPILE_TIME_ASSERT( sint8,   sizeof(Sint8)   == 1  ) ;

  CEYLAN_COMPILE_TIME_ASSERT( uint16,  sizeof(Uint16)  == 2  ) ;
  CEYLAN_COMPILE_TIME_ASSERT( sint16,  sizeof(Sint16)  == 2  ) ;

  CEYLAN_COMPILE_TIME_ASSERT( uint32,  sizeof(Uint32)  == 4  ) ;
  CEYLAN_COMPILE_TIME_ASSERT( sint32,  sizeof(Sint32)  == 4  ) ;
  CEYLAN_COMPILE_TIME_ASSERT( float32, sizeof(Float32) == 4  ) ;

  CEYLAN_COMPILE_TIME_ASSERT( uint64,  sizeof(Uint64)  == 8  ) ;
  CEYLAN_COMPILE_TIME_ASSERT( sint64,  sizeof(Sint64)  == 8  ) ;
  CEYLAN_COMPILE_TIME_ASSERT( float64, sizeof(Float64) == 8  ) ;

  //CEYLAN_COMPILE_TIME_ASSERT( Float96, sizeof(Float96) == 12 ) ;


}



#endif // CEYLAN_TYPES_H_

---