types.h.in

/**
 * @file types.h
 * @author Kumarjit Das
 * @date 2024-07-06
 * @version @TYPES_VERSION_MAJOR@.@TYPES_VERSION_MINOR@.@TYPES_VERSION_PATCH@
 * @brief A simple, header-only C library designed to provide types with sizes.
 */
/**
 * LICENSE:
 *
 * Copyright (c) 2024, Kumarjit Das
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


#ifndef TYPES_H_
#define TYPES_H_


#define KD_DEFINED_LIBTYPES 1

#define TYPES_VERSION_MAJOR @TYPES_VERSION_MAJOR@
#define TYPES_VERSION_MINOR @TYPES_VERSION_MINOR@
#define TYPES_VERSION_PATCH @TYPES_VERSION_PATCH@

#define TYPES_VERSION_STR "@TYPES_VERSION_MAJOR@.@TYPES_VERSION_MINOR@.@TYPES_VERSION_PATCH@"
#define TYPES_VERSION_ARR { TYPES_VERSION_MAJOR, TYPES_VERSION_MINOR, TYPES_VERSION_PATCH }


#include "kdapi.h"


KD_EXTERN_BEGIN


#ifdef KDAPI
  #define TYPESAPI(T) KDAPI(T)
#else
  #define TYPESAPI(T) T
#endif  /* KDAPI */


/**
 * ---------------------------------------------------------------------------------------------------------------------
 *  64-Bit Integer Signatures
 * ---------------------------------------------------------------------------------------------------------------------
 */

#if defined KD_ARCH_64BIT_INT
  #define TYPES_64BIT_INTEGER 1
#elif defined KD_ARCH_32BIT_INT
  #define TYPES_32BIT_INTEGER 1
#endif

#if defined TYPES_64BIT_INTEGER
  #if defined _MSC_VER || defined __BORLANDC__ || defined __WATCOMC__ || (defined __alpha && defined __DECC)
typedef __int64                 kd_types__type_i64_;
typedef unsigned __int64        kd_types__type_u64_;

    #define TYPES_I64(x)        ((kd_types__type_i64_)(x##LL))
    #define TYPES_U64(x)        ((kd_types__type_u64_)(x##ULL))
  #elif defined __GNUC__ || defined __MWERKS__ || defined __SUNPRO_C || defined __SUNPRO_CC || defined __APPLE_CC__ || defined KD_OS_IRIX || defined _LONG_LONG || defined _CRAYC
    #if __SIZEOF_LONG__ == 8
typedef long                    kd_types__type_i64_;
typedef unsigned long           kd_types__type_u64_;

      #define TYPES_I64(x)      ((kd_types__type_i64_)(x##L))
      #define TYPES_U64(x)      ((kd_types__type_u64_)(x##LU))
    #endif
  #elif defined __LP64__ || defined __powerpc64__ || defined KD_CPU_SPARC64
typedef long                    kd_types__type_i64_;
typedef unsigned long           kd_types__type_u64_;

    #define TYPES_I64(x)        ((kd_types__type_i64_)(x))
    #define TYPES_U64(x)        ((kd_types__type_u64_)(x))
  #endif
#elif defined TYPES_PRETEND_64BIT_INTEGER
typedef long                    kd_types__type_i64_;
typedef unsigned long           kd_types__type_u64_;

  #define TYPES_I64(x)          (x)
  #define TYPES_U64(x)          (x)
#endif  /* TYPES_64BIT_INTEGER */

/* A hack from Posh.h library */
#if defined __MINGW32__ && defined KD_ARCH_64BIT_INT
  #undef TYPES_I64
  #undef TYPES_U64
  #define TYPES_I64(x)          ((kd_types__type_i64_)(x##LL))
  #define TYPES_U64(x)          ((kd_types__type_u64_)(x##LLU))
#endif  /* __MINGW32__ */

#if defined KD_ARCH_32BIT_INT
  #define TYPES_I32(x)          (x)
  #define TYPES_U32(x)          (x##U)
#else
  #define TYPES_I32(x)          (x)
  #define TYPES_U32(x)          (x)
#endif


/**
 * ---------------------------------------------------------------------------------------------------------------------
 *  64-Bit Pointer Signature
 * ---------------------------------------------------------------------------------------------------------------------
 */

#if defined KD_ARCH_64BIT_PTR
  #define TYPES_64BIT_POINTER 1
#elif defined KD_ARCH_32BIT_PTR
  #define TYPES_32BIT_POINTER 1
#endif


/**
 * ---------------------------------------------------------------------------------------------------------------------
 *  Type Definitions
 * ---------------------------------------------------------------------------------------------------------------------
 */

typedef void*                     kd_types__type_ptr_;
typedef char                      i8;
typedef i8                        imin;
typedef unsigned char             u8;
typedef u8                        umin;

#ifndef KD_CPLUSPLUS
enum kd_types__type_bool_ { false, true };
typedef enum kd_types__type_bool_ bool;
#endif

#if defined KD_ARCH_32BIT_INT
  #if __SIZEOF_INT__ == 4
typedef short                     i16;
typedef int                       i32;
typedef unsigned short            u16;
typedef unsigned int              u32;
  #elif __SIZEOF_INT__ == 2
typedef int                       i16;
typedef long                      i32;
typedef unsigned int              u16;
typedef unsigned long             u32;
  #endif
#else
typedef short                     i16;
typedef int                       i32;
typedef unsigned short            u16;
typedef unsigned int              u32;
#endif  /* KD_ARCH_32BIT_INT */

#if defined KD_ARCH_64BIT_INT
typedef kd_types__type_i64_       i64;
typedef i64                       imax;
typedef kd_types__type_u64_       u64;
typedef u64                       umax;
typedef u64                       usize;
#elif defined TYPES_PRETEND_64BIT_INTEGER
typedef i32                       i64;
typedef i64                       imax;
typedef u32                       u64;
typedef u64                       umax;
typedef u64                       usize;
#else
typedef i32                       imax;
typedef u32                       umax;
typedef u32                       usize;
#endif  /* KD_ARCH_64BIT_INT */

typedef u8                        byte;
typedef u32                       charcode;
typedef float                     f32;
typedef double                    f64;
typedef f32                       fmin;
typedef f64                       fmax;

union kd_types__type_any_
{
  imax                val;
  kd_types__type_ptr_ ptr;
  byte                slice[8];
  bool                val_bool;
  i8                  val_i8;
  i16                 val_i16;
  i32                 val_i32;
  imin                val_imin;
  imax                val_imax;
  u8                  val_u8;
  u16                 val_u16;
  u32                 val_u32;
  umin                val_umin;
  umax                val_umax;
  usize               val_usize;
  byte                val_byte;
  charcode            val_charcode;
  f32                 val_f32;
  f64                 val_f64;
  fmin                val_fmin;
  fmax                val_fmax;
  bool*               ptr_bool;
  i8*                 ptr_i8;
  i16*                ptr_i16;
  i32*                ptr_i32;
  imin*               ptr_imin;
  imax*               ptr_imax;
  u8*                 ptr_u8;
  u16*                ptr_u16;
  u32*                ptr_u32;
  umin*               ptr_umin;
  umax*               ptr_umax;
  usize*              ptr_usize;
  byte*               ptr_byte;
  charcode*           ptr_charcode;
  f32*                ptr_f32;
  f64*                ptr_f64;
  fmin*               ptr_fmin;
  fmax*               ptr_fmax;

  #if defined KD_ARCH_64BIT_INT || defined TYPES_PRETEND_64BIT_INTEGER
  i64                 val_i64;
  u64                 val_u64;
  i64*                ptr_i64;
  u64*                ptr_u64;
  #endif  /* KD_ARCH_64BIT_INT */
};

typedef union kd_types__type_any_ any;


/**
 * ---------------------------------------------------------------------------------------------------------------------
 *  Minimum Values Of Defined Types
 * ---------------------------------------------------------------------------------------------------------------------
 */

#define MIN_I8       (-128)
#define MIN_I16      (-32768)
#define MIN_I32      (TYPES_I32(-2147483647) - TYPES_I32(1))
#define MIN_IMIN     TYPES_I32(-128)
#define MIN_U8       0
#define MIN_U16      0
#define MIN_U32      TYPES_U32(0)
#define MIN_UMIN     TYPES_U32(0)
#define MIN_BYTE     0
#define MIN_CHARCODE 0
#define MIN_F32      (-1.175494071E-38F)
#define MIN_F64      (-2.22507385850720139E-308)
#define MIN_FMIN     MIN_F32
#define MIN_FMAX     MIN_F64
#define MIN_ANY      0
#define MIN_PTR      ((kd_types__type_ptr_)0)

#if defined KD_ARCH_64BIT_INT
  #define MIN_I64    (TYPES_I64(-9223372036854775807) - TYPES_I64(-1))
  #define MIN_IMAX   MIN_I64
  #define MIN_U64    TYPES_I64(0)
  #define MIN_UMAX   MIN_U64
  #define MIN_USIZE  MIN_U64
#elif defined TYPES_PRETEND_64BIT_INTEGER
  #define MIN_I64    MIN_I32
  #define MIN_IMAX   MIN_I64
  #define MIN_U64    MIN_U32
  #define MIN_UMAX   MIN_U64
  #define MIN_USIZE  MIN_U64
#else
  #define MIN_IMAX   MIN_I32
  #define MIN_UMAX   MIN_U32
  #define MIN_USIZE  MIN_U32
#endif  /* KD_ARCH_64BIT_INT */


/**
 * ---------------------------------------------------------------------------------------------------------------------
 *  Maximum Values Of Defined Types
 * ---------------------------------------------------------------------------------------------------------------------
 */

#define MAX_I8       127
#define MAX_I16      32767
#define MAX_I32      TYPES_I32(2147483647)
#define MAX_IMIN     TYPES_I32(127)
#define MAX_U8       255
#define MAX_U16      65535
#define MAX_U32      TYPES_U32(4294967295)
#define MAX_UMIN     TYPES_U32(255)
#define MAX_BYTE     MAX_U8
#define MAX_CHARCODE MAX_U32
#define MAX_F32      3.402823466E+38F
#define MAX_F64      1.79769313486231571E+308
#define MAX_FMIN     MAX_F32
#define MAX_FMAX     MAX_F64

#if defined KD_ARCH_64BIT_INT || defined TYPES_PRETEND_64BIT_INTEGER
  #define MAX_ANY    MAX_UMAX
#elif KD_ARCH_64BIT_PTR
  #define MAX_ANY    MAX_PTR
#else
  #define MAX_ANY    MAX_U32
#endif  /* KD_ARCH_64BIT_INT */

#if defined KD_ARCH_64BIT_PTR
  #if defined KD_ARCH_64BIT_INT || defined TYPES_PRETEND_64BIT_INTEGER
    #define MAX_PTR  ((kd_types__type_ptr_)MAX_U64)
  #else
    #define MAX_PTR  ((kd_types__type_ptr_)0xFFFFFFFFFFFFFFFF)
  #endif  /* KD_ARCH_64BIT_INT */
#else
  #define MAX_PTR    ((kd_types__type_ptr_)MAX_U32)
#endif  /* KD_ARCH_64BIT_PTR */

#if defined KD_ARCH_64BIT_INT
  #define MAX_I64    TYPES_I64(9223372036854775807)
  #define MAX_IMAX   MAX_I64
  #define MAX_U64    TYPES_U64(18446744073709551615)
  #define MAX_UMAX   MAX_U64
  #define MAX_USIZE  MAX_U64
#elif defined TYPES_PRETEND_64BIT_INTEGER
  #define MAX_I64    MAX_I32
  #define MAX_IMAX   MAX_I64
  #define MAX_U64    MAX_U32
  #define MAX_UMAX   MAX_U64
  #define MAX_USIZE  MAX_U64
#else
  #define MAX_IMAX   MAX_I32
  #define MAX_UMAX   MAX_U32
  #define MAX_USIZE  MAX_U32
#endif  /* KD_ARCH_64BIT_INT */


/**
 * ---------------------------------------------------------------------------------------------------------------------
 *  Constant Values/Macros
 * ---------------------------------------------------------------------------------------------------------------------
 */

#if defined null
  #undef null
#endif  /* null */

#if defined EXIT_SUCCESS
  #undef EXIT_SUCCESS
#endif  /* EXIT_SUCCESS */

#if defined EXIT_FAILURE
  #undef EXIT_FAILURE
#endif  /* EXIT_FAILURE */

#define null         ((kd_types__type_ptr_)0x00)
#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1


/**
 * ---------------------------------------------------------------------------------------------------------------------
 *  Sizes Of Defined Types (In Bytes)
 * ---------------------------------------------------------------------------------------------------------------------
 */

#define SZ_BOOL     sizeof(bool)
#define SZ_I8       sizeof(i8)
#define SZ_I16      sizeof(i16)
#define SZ_I32      sizeof(i32)
#define SZ_IMIN     sizeof(imin)
#define SZ_IMAX     sizeof(imax)
#define SZ_U8       sizeof(u8)
#define SZ_U16      sizeof(u16)
#define SZ_U32      sizeof(u32)
#define SZ_UMIN     sizeof(umin)
#define SZ_UMAX     sizeof(umax)
#define SZ_USIZE    sizeof(usize)
#define SZ_BYTE     sizeof(byte)
#define SZ_CHARCODE sizeof(charcode)
#define SZ_F32      sizeof(f32)
#define SZ_F64      sizeof(f64)
#define SZ_FMIN     sizeof(fmin)
#define SZ_FMAX     sizeof(fmax)
#define SZ_ANY      sizeof(any)
#define SZ_PTR      sizeof(kd_types__type_ptr_)

#if defined KD_ARCH_64BIT_INT || defined TYPES_PRETEND_64BIT_INTEGER
  #define SZ_I64    sizeof(i64)
  #define SZ_U64    sizeof(u64)
#endif


/**
 * ---------------------------------------------------------------------------------------------------------------------
 *  C-style Format Specifiers
 * ---------------------------------------------------------------------------------------------------------------------
 */

#define FMTSP_BOOL       "%s"
#define FMTSP_I8         "%d"
#define FMTSP_I16        "%d"
#define FMTSP_IMIN       "%d"
#define FMTSP_U8         "%u"
#define FMTSP_U16        "%u"
#define FMTSP_UMIN       "%u"
#define FMTSP_BYTE       "%u"
#define FMTSP_F32        "%.9e"
#define FMTSP_F64        "%.17e"
#define FMTSP_FMIN       "%.9e"
#define FMTSP_FMAX       "%.17e"
#define FMTSP_PTR        "%p"

#if defined KD_ARCH_32BIT_INT
  #if __SIZEOF_INT__ == 4
    #define FMTSP_I32    "%d"
    #define FMTSP_U32    "%u"
  #elif __SIZEOF_INT__ == 2
    #define FMTSP_I32    "%ld"
    #define FMTSP_U32    "%lu"
  #endif
#else
  #define FMTSP_I32      "%d"
  #define FMTSP_U32      "%u"
#endif  /* KD_ARCH_32BIT_INT */

#define FMTSP_CHARCODE  FMTSP_U32

#if defined KD_ARCH_64BIT_INT
  #ifdef KD_COMP_MSVC
    #define FMTSP_I64    "%lld"
    #define FMTSP_U64    "%llu"
    #define FMTSP_IMAX   "%lld"
    #define FMTSP_UMAX   "%llu"
    #define FMTSP_USIZE  "%llu"
  #else
    #define FMTSP_I64    "%ld"
    #define FMTSP_U64    "%lu"
    #define FMTSP_IMAX   "%ld"
    #define FMTSP_UMAX   "%lu"
    #define FMTSP_USIZE  "%lu"
  #endif  /* KD_COMP_MSVC */
#elif defined TYPES_PRETEND_64BIT_INTEGER
  #define FMTSP_I64      FMTSP_I32
  #define FMTSP_U64      FMTSP_I64
  #define FMTSP_IMAX     FMTSP_U32
  #define FMTSP_UMAX     FMTSP_U64
  #define FMTSP_USIZE    FMTSP_U64
#else
  #define FMTSP_IMAX     FMTSP_I32
  #define FMTSP_UMAX     FMTSP_U32
  #define FMTSP_USIZE    FMTSP_U32
#endif  /* KD_ARCH_64BIT_INT */

#if defined KD_ARCH_64BIT_INT || defined TYPES_PRETEND_64BIT_INTEGER
  #define FMTSP_ANY      FMTSP_UMAX
#elif KD_ARCH_64BIT_PTR
  #define FMTSP_ANY      FMTSP_PTR
#else
  #define FMTSP_ANY      FMTSP_U32
#endif  /* KD_ARCH_64BIT_INT */

#define FMTSP_ANY_SLICES "%d|%d|%d|%d|%d|%d|%d|%d"


/**
 * ---------------------------------------------------------------------------------------------------------------------
 *  C-style Format Specifier Based Type Cast
 * ---------------------------------------------------------------------------------------------------------------------
 */

#define FSBTC_BOOL(x)       ((x) ? "true" : "false")
#define FSBTC_I8(x)         (int) (x)
#define FSBTC_I16(x)        (int) (x)
#define FSBTC_IMIN(x)       (int) (x)
#define FSBTC_U8(x)         (unsigned int) (x)
#define FSBTC_U16(x)        (unsigned int) (x)
#define FSBTC_UMIN(x)       (unsigned int) (x)
#define FSBTC_BYTE(x)       (unsigned int) (x)
#define FSBTC_F32(x)        (double) (x)
#define FSBTC_F64(x)        (x)
#define FSBTC_FMIN(x)       FSBTC_F32(x)
#define FSBTC_FMAX(x)       FSBTC_F64(x)
#define FSBTC_PTR(x)        (kd_types__type_ptr_) (x)

#if defined KD_ARCH_32BIT_INT
  #if __SIZEOF_INT__ == 4
    #define FSBTC_I32(x)    (x)
    #define FSBTC_U32(x)    (unsigned int) (x)
  #elif __SIZEOF_INT__ == 2
    #define FSBTC_I32(x)    (long) (x)
    #define FSBTC_U32(x)    (unsigned long) (x)
  #endif
#else
  #define FSBTC_I32(x)      (x)
  #define FSBTC_U32(x)      (unsigned int) (x)
#endif  /* KD_ARCH_32BIT_INT */

#define FSBTC_CHARCODE(x)   FSBTC_U32(x)

#if defined KD_ARCH_64BIT_INT
  #ifdef KD_COMP_MSVC
    #define FSBTC_I64(x)    (long long) (x)
    #define FSBTC_U64(x)    (unsigned long long) (x)
    #define FSBTC_IMAX(x)   (long long) (x)
    #define FSBTC_UMAX(x)   (unsigned long long) (x)
    #define FSBTC_USIZE(x)  (unsigned long long) (x)
  #else
    #define FSBTC_I64(x)    (long) (x)
    #define FSBTC_U64(x)    (unsigned long) (x)
    #define FSBTC_IMAX(x)   (long) (x)
    #define FSBTC_UMAX(x)   (unsigned long) (x)
    #define FSBTC_USIZE(x)  (unsigned long) (x)
  #endif  /* KD_COMP_MSVC */
#elif defined TYPES_PRETEND_64BIT_INTEGER
  #define FSBTC_I64(x)      FSBTC_I32(x)
  #define FSBTC_U64(x)      FSBTC_I64(x)
  #define FSBTC_IMAX(x)     FSBTC_U32(x)
  #define FSBTC_UMAX(x)     FSBTC_U64(x)
  #define FSBTC_USIZE(x)    FSBTC_U64(x)
#else
  #define FSBTC_IMAX(x)     FSBTC_I32(x)
  #define FSBTC_UMAX(x)     FSBTC_U32(x)
  #define FSBTC_USIZE(x)    FSBTC_U32(x)
#endif  /* KD_ARCH_64BIT_INT */

#if defined KD_ARCH_64BIT_INT || defined TYPES_PRETEND_64BIT_INTEGER
  #define FSBTC_ANY(x)      FSBTC_UMAX(x)
#elif KD_ARCH_64BIT_PTR
  #define FSBTC_ANY(x)      FSBTC_PTR(x)
#else
  #define FSBTC_ANY(x)      FSBTC_U32(x)
#endif  /* KD_ARCH_64BIT_INT */

#define FSBTC_ANY_SLICES(x) \
  (int) (x).slice[0], (int) (x).slice[1], \
  (int) (x).slice[2], (int) (x).slice[3], \
  (int) (x).slice[4], (int) (x).slice[5], \
  (int) (x).slice[6], (int) (x).slice[7]


/**
 * ---------------------------------------------------------------------------------------------------------------------
 *  Value Assignment
 * ---------------------------------------------------------------------------------------------------------------------
 */

#define ASSIGN_ANY(x, v0, v1, v2, v3, v4, v5, v6, v7) \
  (x).slice[0] = v0; \
  (x).slice[1] = v1; \
  (x).slice[2] = v2; \
  (x).slice[3] = v3; \
  (x).slice[4] = v4; \
  (x).slice[5] = v5; \
  (x).slice[6] = v6; \
  (x).slice[7] = v7


KD_EXTERN_END


#endif  /* TYPES_H_ */