X-Git-Url: https://pd.if.org/git/?a=blobdiff_plain;f=_PDCLIB_int.h;fp=_PDCLIB_int.h;h=af65596f89b49876eed8d39c42232eeb8d32d594;hb=89c516d1b45766b519f60b986366a3c592ec5760;hp=0000000000000000000000000000000000000000;hpb=b8621b671ffce31002c06f707658f848dd0c0d2a;p=pdclib diff --git a/_PDCLIB_int.h b/_PDCLIB_int.h new file mode 100644 index 0000000..af65596 --- /dev/null +++ b/_PDCLIB_int.h @@ -0,0 +1,254 @@ +/* $Id$ */ + +/* Internal PDCLib logic <_PDCLIB_internal.h> + + This file is part of the Public Domain C Library (PDCLib). + Permission is granted to use, modify, and / or redistribute at will. +*/ + +/* -------------------------------------------------------------------------- */ +/* You should not have to edit anything in this file; if you DO have to, it */ +/* would be considered a bug / missing feature: notify the author. */ +/* -------------------------------------------------------------------------- */ + +#include <_PDCLIB_config.h> + +/* null pointer constant */ +#define _PDCLIB_NULL 0 + +/* -------------------------------------------------------------------------- */ +/* Helper macros: */ +/* _PDCLIB_cc( x, y ) concatenates two preprocessor tokens without extending */ +/* _PDCLIB_concat( x, y ) concatenates two preprocessor tokens with extending */ +/* -------------------------------------------------------------------------- */ + +#define _PDCLIB_cc( x, y ) x ## y +#define _PDCLIB_concat( x, y ) _PDCLIB_cc( x, y ) + +/* -------------------------------------------------------------------------- */ +/* Limits of native datatypes */ +/* -------------------------------------------------------------------------- */ +/* The definition of minimum limits for unsigned datatypes is done because */ +/* later on we will "construct" limits for other abstract types: */ +/* USHRT -> _PDCLIB_ + USHRT + _MIN -> _PDCLIB_USHRT_MIN -> 0 */ +/* INT -> _PDCLIB_ + INT + _MIN -> _PDCLIB_INT_MIN -> ... you get the idea. */ +/* -------------------------------------------------------------------------- */ + +/* Setting 'char' limits */ +#define _PDCLIB_CHAR_BIT 8 +#define _PDCLIB_UCHAR_MIN 0 +#define _PDCLIB_UCHAR_MAX 0xff +#define _PDCLIB_SCHAR_MIN (-0x7f - 1) +#define _PDCLIB_SCHAR_MAX 0x7f +#ifdef _PDCLIB_CHAR_SIGNED +#define _PDCLIB_CHAR_MIN _PDCLIB_SCHAR_MIN +#define _PDCLIB_CHAR_MAX _PDCLIB_SCHAR_MAX +#else +#define _PDCLIB_CHAR_MIN 0 +#define _PDCLIB_CHAR_MAX _PDCLIB_UCHAR_MAX +#endif + +/* Setting 'short' limits */ +#if _PDCLIB_SHRT_BYTES == 1 +#define _PDCLIB_SHRT_MAX 0x7f +#define _PDCLIB_SHRT_MIN (-0x7f - 1) +#define _PDCLIB_USHRT_MAX 0xff +#elif _PDCLIB_SHRT_BYTES == 2 +#define _PDCLIB_SHRT_MAX 0x7fff +#define _PDCLIB_SHRT_MIN (-0x7fff - 1) +#define _PDCLIB_USHRT_MAX 0xffff +#else +#error Unsupported width of 'short' (neither 8 nor 16 bit). +#endif +#define _PDCLIB_USHRT_MIN 0 + +/* Setting 'int' limits */ +#if _PDCLIB_INT_BYTES == 2 +#define _PDCLIB_INT_MAX 0x7fff +#define _PDCLIB_INT_MIN (-0x7fff - 1) +#define _PDCLIB_UINT_MAX 0xffffU +#elif _PDCLIB_INT_BYTES == 4 +#define _PDCLIB_INT_MAX 0x7fffffff +#define _PDCLIB_INT_MIN (-0x7fffffff - 1) +#define _PDCLIB_UINT_MAX 0xffffffffU +#elif _PDCLIB_INT_BYTES == 8 +#define _PDCLIB_INT_MAX 0x7fffffffffffffff +#define _PDCLIB_INT_MIN (-0x7fffffffffffffff - 1) +#define _PDCLIB_UINT_MAX 0xffffffffffffffff +#else +#error Unsupported width of 'int' (neither 16, 32, nor 64 bit). +#endif +#define _PDCLIB_UINT_MIN 0 + +/* Setting 'long' limits */ +#if _PDCLIB_LONG_BYTES == 4 +#define _PDCLIB_LONG_MAX 0x7fffffffL +#define _PDCLIB_LONG_MIN (-0x7fffffffL - 1L) +#define _PDCLIB_LONG_MAX 0xffffffffUL +#elif _PDCLIB_LONG_BYTES == 8 +#define _PDCLIB_LONG_MAX 0x7fffffffffffffffL +#define _PDCLIB_LONG_MIN (-0x7fffffffffffffffL - 1L) +#define _PDCLIB_ULONG_MAX 0xffffffffffffffffUL +#else +#error Unsupported width of 'long' (neither 32 nor 64 bit). +#endif +#define _PDCLIB_ULONG_MIN 0 + +/* Setting 'long long' limits */ +#if _PDCLIB_LLONG_BYTES == 8 +#define _PDCLIB_LLONG_MAX 0x7fffffffffffffffLL +#define _PDCLIB_LLONG_MIN (-0x7fffffffffffffffLL - 1LL) +#define _PDCLIB_ULLONG_MAX 0xffffffffffffffffULL +#elif _PDCLIB_LLONG_BYTES == 16 +#define _PDCLIB_LLONG_MAX 0x7fffffffffffffffffffffffffffffffLL +#define _PDCLIB_LLONG_MIN (-0x7fffffffffffffffffffffffffffffffLL - 1LL) +#define _PDCLIB_ULLONG_MAX 0xffffffffffffffffffffffffffffffffLL +#else +#error Unsupported width of 'long long' (neither 64 nor 128 bit). +#endif +#define _PDCLIB_ULLONG_MIN 0 + +/* -------------------------------------------------------------------------- */ +/* exact-width types, their limits and literals */ +/* -------------------------------------------------------------------------- */ + +/* Setting 'int8_t', its limits, and its literal. */ +#if _PDCLIB_SHRT_BYTES == 1 +typedef signed short _PDCLIB_int8_t; +typedef unsigned short _PDCLIB_int8_t; +#define _PDCLIB_INT8_MAX _PDCLIB_SHRT_MAX +#define _PDCLIB_INT8_MIN _PDCLIB_SHRT_MIN +#define _PDCLIB_UINT8_MAX _PDCLIB_USHRT_MAX +#else +typedef signed char _PDCLIB_int8_t; +typedef unsigned char _PDCLIB_uint8_t; +#define _PDCLIB_INT8_MAX _PDCLIB_CHAR_MAX +#define _PDCLIB_INT8_MIN _PDCLIB_CHAR_MIN +#define _PDCLIB_UINT8_MAX _PDCLIB_UCHAR_MAX +#endif + +/* Setting 'int16_t', its limits, and its literal */ +#if _PDCLIB_INT_BYTES == 2 +typedef signed int _PDCLIB_int16_t; +typedef unsigned int _PDCLIB_uint16_t; +#define _PDCLIB_INT16_MAX _PDCLIB_INT_MAX +#define _PDCLIB_INT16_MIN _PDCLIB_INT_MIN +#define _PDCLIB_UINT16_MAX _PDCLIB_UINT_MAX +#elif _PDCLIB_SHRT_BYTES == 2 +typedef signed short _PDCLIB_int16_t; +typedef unsigned short _PDCLIB_int16_t; +#define _PDCLIB_INT16_MAX _PDCLIB_SHRT_MAX +#define _PDCLIB_INT16_MIN _PDCLIB_SHRT_MIN +#define _PDCLIB_UINT16_MAX _PDCLIB_USHRT_MAX +#else +#error Neither 'short' nor 'int' are 16-bit. +#endif + +/* Setting 'int32_t', its limits, and its literal */ +#if _PDCLIB_INT_BYTES == 4 +typedef signed int _PDCLIB_int32_t; +typedef unsigned int _PDCLIB_int32_t; +#define _PDCLIB_INT32_MAX _PDCLIB_INT_MAX +#define _PDCLIB_INT32_MIN _PDCLIB_INT_MIN +#define _PDCLIB_UINT32_MAX _PDCLIB_UINT_MAX +#elif _PDCLIB_LONG_BYTES == 4 +typedef signed long _PDCLIB_int32_t; +typedef unsigned long _PDCLIB_int32_t; +#define _PDCLIB_INT32_MAX _PDCLIB_LONG_MAX +#define _PDCLIB_INT32_MIN _PDCLIB_LONG_MIN +#define _PDCLIB_UINT32_MAX _PDCLIB_LONG_MAX +#else +#error Neither 'int' nor 'long' are 32-bit. +#endif + +#if _PDCLIB_LONG_BYTES == 8 +typedef signed long _PDCLIB_int64_t; +typedef unsigned long _PDCLIB_int64_t; +#define _PDCLIB_INT64_MAX _PDCLIB_LONG_MAX +#define _PDCLIB_INT64_MIN _PDCLIB_LONG_MIN +#define _PDCLIB_INT64_MAX _PDCLIB_ULONG_MAX +#elif _PDCLIB_LLONG_BYTES == 8 +typedef signed long long _PDCLIB_int64_t; +typedef unsigned long long _PDCLIB_int64_t; +#define _PDCLIB_INT64_MAX _PDCLIB_LLONG_MAX +#define _PDCLIB_INT64_MIN _PDCLIB_LLONG_MIN +#define _PDCLIB_INT64_MAX _PDCLIB_ULLONG_MAX +#else +#error Neither 'long' nor 'long long' are 64-bit. +#endif + +/* -------------------------------------------------------------------------- */ +/* "fastest" types and their limits */ +/* -------------------------------------------------------------------------- */ +/* This is, admittedly, butt-ugly. But at least it's ugly where the average */ +/* user of PDCLib will never see it, and makes <_PDCLIB_config.h> much */ +/* cleaner. */ +/* -------------------------------------------------------------------------- */ + +typedef _PDCLIB_fast8 _PDCLIB_int_fast8_t; +typedef unsigned _PDCLIB_fast8 _PDCLIB_uint_fast8_t; +#define _PDCLIB_INT_FAST8_MIN concat( concat( _PDCLIB_, _PDCLIB_FAST8 ), _MIN ) +#define _PDCLIB_INT_FAST8_MAX concat( concat( _PDCLIB_, _PDCLIB_FAST8 ), _MAX ) +#define _PDCLIB_UINT_FAST8_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST8 ), _MAX ) + +typedef _PDCLIB_fast16 _PDCLIB_int_fast16_t; +typedef unsigned _PDCLIB_fast16 _PDCLIB_uint_fast16_t; +#define _PDCLIB_INT_FAST16_MIN concat( concat( _PDCLIB_, _PDCLIB_FAST16 ), _MIN ) +#define _PDCLIB_INT_FAST16_MAX concat( concat( _PDCLIB_, _PDCLIB_FAST16 ), _MAX ) +#define _PDCLIB_UINT_FAST16_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST16 ), _MAX ) + +typedef _PDCLIB_fast32 _PDCLIB_int_fast32_t; +typedef unsigned _PDCLIB_fast32 _PDCLIB_uint_fast32_t; +#define _PDCLIB_INT_FAST32_MIN concat( concat( _PDCLIB_, _PDCLIB_FAST32 ), _MIN ) +#define _PDCLIB_INT_FAST32_MAX concat( concat( _PDCLIB_, _PDCLIB_FAST32 ), _MAX ) +#define _PDCLIB_UINT_FAST32_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST32 ), _MAX ) + +typedef _PDCLIB_fast64 _PDCLIB_int_fast64_t; +typedef unsigned _PDCLIB_fast64 _PDCLIB_uint_fast64_t; +#define _PDCLIB_INT_FAST64_MIN concat( concat( _PDCLIB_, _PDCLIB_FAST64 ), _MIN ) +#define _PDCLIB_INT_FAST64_MAX concat( concat( _PDCLIB_, _PDCLIB_FAST64 ), _MAX ) +#define _PDCLIB_UINT_FAST64_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST64 ), _MAX ) + +/* -------------------------------------------------------------------------- */ +/* Various limits */ +/* -------------------------------------------------------------------------- */ + +#define _PDCLIB_PTRDIFF_MIN concat( concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MIN ) +#define _PDCLIB_PTRDIFF_MAX concat( concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MAX ) + +#define _PDCLIB_SIG_ATOMIC_MIN concat( concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MIN ) +#define _PDCLIB_SIG_ATOMIC_MAX concat( concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MAX ) + +#define _PDCLIB_SIZE_MAX concat( concat( _PDCLIB_, _PDCLIB_SIZE ), _MAX ) + +#define _PDCLIB_WCHAR_MIN concat( concat( _PDCLIB_, _PDCLIB_WCHAR ), _MIN ) +#define _PDCLIB_WCHAR_MAX concat( concat( _PDCLIB_, _PDCLIB_WCHAR ), _MAX ) + +/* -------------------------------------------------------------------------- */ +/* "exact width" literal suffixes */ +/* -------------------------------------------------------------------------- */ + +#define _PDCLIB_INT8_LITERAL c +#define _PDCLIB_INT16_LITERAL s +#define _PDCLIB_INT32_LITERAL l +#define _PDCLIB_INT64_LITERAL ll +#define _PDCLIB_UINT8_LITERAL uc +#define _PDCLIB_UINT16_LITERAL us +#define _PDCLIB_UINT32_LITERAL ul +#define _PDCLIB_UINT64_LITERAL ull + +/* -------------------------------------------------------------------------- */ +/* "fast" typedefs */ +/* -------------------------------------------------------------------------- */ + +typedef int _PDCLIB_intptr_t; +#define _PDCLIB_INTPTR_MIN (-0x7fffff - 1) +#define _PDCLIB_INTPTR_MAX 0x7fffff +typedef unsigned int _PDCLIB_uintptr_t; +#define _PDCLIB_UINTPTR_MAX 0xffffff + +typedef signed long long int _PDCLIB_intmax_t; +#define _PDCLIB_INTMAX_MIN (-0x7fffffffffffffff - 1) +#define _PDCLIB_INTMAX_MAX 0x7fffffffffffffff +typedef unsigned long long int _PDCLIB_uintmax_t; +#define _PDCLIB_UINTMAX_MAX 0xffffffffffffffff