stdint.h

Go to the documentation of this file.

/*---------------------------------------------------------------------------------
 * /
 * / apeNEXT stdint for nlcc
 * /
 * / $Id: stdint.h,v 1.11 2005/06/08 14:06:53 pleiter Exp $
 * /
 * /
 * / ISO/IEC 9899:1999 (E) Standard
 * / Integer types  <stdint.h>
 * /
 * /
 * /
 * / IMPLEMENTATION for APEnext: Implem                                 (stdint.h) 
 * / 
 * / IMPLEMENTATION for APEnext: Implem int64_t
 * / IMPLEMENTATION for APEnext: Implem uint64_t
 * / IMPLEMENTATION for APEnext: Implem LLONG_MIN
 * / IMPLEMENTATION for APEnext: Implem ULLONG_MIN
 * / IMPLEMENTATION for APEnext: Implem LLONG_MAX
 * / IMPLEMENTATION for APEnext: Implem ULLONG_MAX
 * /-----------------------------------------------------------------------------*/

#ifndef _STDINT_H
#define _STDINT_H

#include <nlibc.h>
#include <limits.h>

/*---------------------------------------------------------------------------------
 * / NAME   
 * /           stdint.h - definition of integer types
 * /
 * / SYNOPSIS
 * /           #include <stdint.h>
 * /
 * / DESCRIPTION
 * /           The <stdint.h> header declares sets of integer types with specified 
 * /           widths, and defines corresponding sets of macros. 
 * /           It also defines macros that specify limits of integer types 
 * /           corresponding to types defined in other standard headers, 
 * /           like <inttypes.h> and <limits.h>
 * /
 * / Notes
 * /           The "width" of an integer type is the number of bits used to 
 * /           store its value in a pure binary system 
 * /     
 * / IMPLEMENTATION for APEnext:   
 * /           Types are defined in the following categories:
 * /              Integer having certain exact widths
 * /              Integer having at least certain specified widths
 * /              Fastest integer having at least certain specified widths
 * /              Integer wide enough to hold pointers to objects
 * /              Integer having greatest width                
 * /-----------------------------------------------------------------------------*/

/* exact-width types...    
   ++++OPTIONAL++++ 
   The EXACT width available in apeNEXT is 64 bit. Therefore ONLY int64_t
   and uint64_t can be defined */       
//typedef short                  int8_t; 
//typedef int                    int16_t;
//typedef long int               int32_t; 
typedef long long int          int64_t;
typedef unsigned long long int uint64_t;

/* lower and upper bound of exact-width integer types... 
   ++++OPTIONAL++++ 
   Also here the lower of upper size of EXACT width is 
   as given above restrected */
//#define INT8_MIN          SHRT_MIN
//#define INT16_MIN         INT_MIN
//#define INT32_MIN         LONG_MIN
#define INT64_MIN         LLONG_MIN

//#define INT8_MAX          SHRT_MAX
//#define INT16_MAX         INT_MAX
//#define INT32_MAX         LONG_MAX
#define INT64_MAX         LLONG_MAX

//#define UINT8_MAX         USHRT_MAX
//#define UINT16_MAX        UINT_MAX
//#define UINT32_MAX        ULONG_MAX
#define UINT64_MAX        ULLONG_MAX

#define INTMAX_MIN        INT64_MIN
#define INTMAX_MAX        INT64_MAX
#define UINTMAX_MAX       UINT64_MAX

/* minimum-width signed and unsigned integer types...  
   ++++REQUIRED++++ 
   As argumented above following definations are ALSO possible */
typedef short int               int_least8_t;
typedef int                     int_least16_t;
typedef long int                int_least32_t;
typedef long long int           int_least64_t;      

typedef unsigned short int      uint_least8_t;
typedef unsigned int            uint_least16_t;
typedef unsigned long int       uint_least32_t;
typedef unsigned long long int  uint_least64_t;      


/* lower and upper bound of AT-LEAST width integer types... 
   ++++ REQUIRED ++++ 
   As argumented above following definations are ALSO possible */
#define INT_LEAST8_MIN    SHRT_MIN   //  
#define INT_LEAST16_MIN   INT_MIN    // 
#define INT_LEAST32_MIN   LONG_MIN   // 
#define INT_LEAST64_MIN   LLONG_MIN  // 

#define INT_LEAST8_MAX    SHRT_MAX   //
#define INT_LEAST16_MAX   INT_MAX    // 
#define INT_LEAST32_MAX   LONG_MAX   // 
#define INT_LEAST64_MAX   LLONG_MAX  // 

#define UINT_LEAST8_MAX   USHRT_MAX  //
#define UINT_LEAST16_MAX  UINT_MAX   //
#define UINT_LEAST32_MAX  ULONG_MAX  //
#define UINT_LEAST64_MAX  ULLONG_MAX //

/* fastest minimum-width signed and unsigned integer types... 
   ++++REQUIRED++++ */
typedef short int               int_fast8_t;
typedef int                     int_fast16_t;
typedef long int                int_fast32_t;
typedef long long int           int_fast64_t;        

typedef unsigned short int      uint_fast8_t;
typedef unsigned int            uint_fast16_t;
typedef unsigned long int       uint_fast32_t;
typedef unsigned long long int  uint_fast64_t;      

/* lower and upper bound of fastest minimum-width integer types... 
   ++++REQUIRED++++ */
#define INT_FAST8_MIN     SHRT_MIN   // 
#define INT_FAST16_MIN    INT_MIN    // 
#define INT_FAST32_MIN    LONG_MIN   // 
#define INT_FAST64_MIN    LLONG_MIN  // 

#define INT_FAST8_MAX     SHRT_MAX   // 
#define INT_FAST16_MAX    INT_MAX    // 
#define INT_FAST32_MAX    LONG_MAX   // 
#define INT_FAST64_MAX    LLONG_MAX  // 

#define UINT_FAST8_MAX    USHRT_MAX  //
#define UINT_FAST16_MAX   UINT_MAX   //
#define UINT_FAST32_MAX   ULONG_MAX  //
#define UINT_FAST64_MAX   ULLONG_MAX //

/* maximum-width integer types used by pointers ... */
typedef int64_t                 intptr_t;
typedef uint64_t                uintptr_t;

#define INTPTR_MIN              LLONG_MIN
#define INTPTR_MAX              LLONG_MAX
#define UINTPTR_MAX             ULLONG_MAX

typedef int64_t                 intmax_t;
typedef uint64_t                uintmax_t;


/* ========================================================================= 
!! The following macro expands to an integer constant-expression having 
!! the value specified (MINIMUM) by its argument and the corresponding type.
!! =======================================================================*/

#define   INT8_C(value)   value
#define  INT16_C(value)   value 
#define  INT32_C(value)   value ##L   // long
#define  INT64_C(value)   value ##LL  // long long
#define  UINT8_C(value)   value ##U   // unsigned 
#define UINT16_C(value)   value ##U   // unsigned 
#define UINT32_C(value)   value ##UL  // unsigned long
#define UINT64_C(value)   value ##ULL // unsigned long long 

/*              ++++ maximum-width integer ++++              */    
#define   INTMAX_C(value) value ##L   // int    
#define  UINTMAX_C(value) value ##UL  // uint   
#define  LONGMAX_C(value) value ##LL  // long   
#define ULONGMAX_C(value) value ##ULL // ulong  


/* limits for other integer types... 
   ++++OPTIONAL++++*/
#ifndef _PTRDIFF_T
#define _PTRDIFF_T
typedef int    ptrdiff_t;    /* difference of two pointers */
#endif 
#ifndef PTRDIFF_MIN
#define PTRDIFF_MIN       INT64_MIN
#endif 
#ifndef PTRDIFF_MAX
#define PTRDIFF_MAX       INT64_MAX
#endif 

#define SIG_ATOMIC_MIN    INT_MIN
#define SIG_ATOMIC_MAX    INT_MAX

/* +++ for 64 bit SIZE_MAX defined as 18446744073709551615UL +++ */
#define SIZE_MAX          UINT_MAX 
#define WINT_MIN          INT64_MIN
#define WINT_MAX          INT64_MAX

#endif /* ifndef _STDINT_H */

/*                                                                            @AT*/

---