src/starboard/types.h

// Copyright 2015 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Module Overview: Starboard Types module
//
// Provides a suite of standard types that should be universally available on
// all platforms, specifically focused on explicitly-sized integer types and
// booleans. This module also includes some related ubiquitous definitions like
// limits of the explicitly-sized integer types, and standard pointer and int32
// sentinel values.

#ifndef STARBOARD_TYPES_H_
#define STARBOARD_TYPES_H_

#include "starboard/configuration.h"

#if SB_HAS(STDBOOL_H) && !defined(__cplusplus)
#include <stdbool.h>
#endif  // SB_HAS(STDBOOL_H) && !defined(__cplusplus)

#if SB_HAS(STDINT_H)
#include <stdint.h>
#endif

#if SB_HAS(INTTYPES_H)
#include <inttypes.h>
#endif  // SB_HAS(STDINT_H)

#if SB_HAS(SYS_TYPES_H)
#include <sys/types.h>
#endif  // SB_HAS(SYS_TYPES_H)

#if SB_HAS(STDDEF_H)
#include <stddef.h>
#endif

#if SB_HAS(LIMITS_H)
#include <limits.h>
#endif

#if SB_HAS(STDARG_H)
#include <stdarg.h>
#endif

#if SB_HAS(FLOAT_H)
#include <float.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

// --- Standard Include Emulation ----------------------------------------------

// Simulate stdint.h for platforms that don't provide it.
#if !SB_HAS(STDINT_H) && !SB_HAS(INTTYPES_H)
#if !defined(SB_INT8) || !defined(SB_UINT8) || !defined(SB_INT16) ||    \
    !defined(SB_UINT16) || !defined(SB_INT32) || !defined(SB_UINT32) || \
    !defined(SB_INT64) || !defined(SB_UINT64) || !defined(SB_INTPTR) || \
    !defined(SB_UINTPTR)
#error "No stdint.h or inttypes.h, so define SB_U?INT(8|16|32|64|PTR)."
#endif  // !defined(SB_U?INT(8|16|32|64|PTR))
typedef SB_INT8 int8_t;
typedef SB_UINT8 uint8_t;

typedef SB_INT16 int16_t;
typedef SB_UINT16 uint16_t;

typedef SB_INT32 int32_t;
typedef SB_UINT32 uint32_t;

typedef SB_INT64 int64_t;
typedef SB_UINT64 uint64_t;

typedef SB_INTPTR intptr_t;
typedef SB_UINTPTR uintptr_t;
#endif  // !SB_HAS(STDINT_H) && !SB_HAS(INTTYPES_H)

#if !SB_HAS(SSIZE_T)
#if SB_IS(32_BIT)
typedef int32_t ssize_t;
#elif SB_IS(64_BIT)
typedef int64_t ssize_t;
#endif
#endif  // !SB_HAS(SSIZE_T)

// Simulate stdbool.h for platforms that don't provide it.
#if !SB_HAS(STDBOOL_H) && !defined(__cplusplus)
#if __STDC_VERSION__ >= 199901L
#define bool _Bool
#else
#define bool int
#endif
#define false 0
#define true 1
#endif  // !SB_HAS(STDBOOL_H) && !defined(__cplusplus)

// Simulate stddef.h for platforms that don't provide it.
#if !SB_HAS(STDDEF_H)
#define NULL ((void*)0)
#endif

// Simulate needed portions of limits.h for platforms that don't provide it.

// Assume int is 32-bits until we find a platform for which that fails.
SB_COMPILE_ASSERT(sizeof(int) == sizeof(int32_t),  // NOLINT[runtime/int]
                  starboard_int_is_32_bits);
#if !defined(UINT_MAX)
#define UINT_MAX 0xFFFFFFFFU
#endif

#if !defined(INT_MIN)
#define INT_MIN 0x80000000
#endif

#if !defined(INT_MAX)
#define INT_MAX 0x7FFFFFFF
#endif

#if SB_HAS(32_BIT_LONG)

SB_COMPILE_ASSERT(sizeof(long) == sizeof(int32_t),  // NOLINT[runtime/int]
                  starboard_long_is_32_bits);
#if !defined(LONG_MIN)
#define LONG_MIN INT_MIN
#endif

#if !defined(LONG_MAX)
#define LONG_MAX INT_MAX
#endif

#if !defined(ULONG_MAX)
#define ULONG_MAX UINT_MAX
#endif

#else  // SB_HAS(32_BIT_LONG)

SB_COMPILE_ASSERT(sizeof(long) == sizeof(int64_t),  // NOLINT[runtime/int]
                  starboard_long_is_64_bits);
#if !defined(LONG_MIN)
#define LONG_MIN SB_INT64_C(0x8000000000000000)
#endif

#if !defined(LONG_MAX)
#define LONG_MAX SB_INT64_C(0x7FFFFFFFFFFFFFFF)
#endif

#if !defined(ULONG_MAX)
#define ULONG_MAX SB_INT64_C(0xFFFFFFFFFFFFFFFF)
#endif

#endif  // SB_HAS(32_BIT_LONG)

#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4310)  // Cast truncates constant value.
#endif

static const int8_t kSbInt8Min = ((int8_t)0x80);
static const int8_t kSbInt8Max = ((int8_t)0x7F);
static const uint8_t kSbUInt8Max = ((uint8_t)0xFF);

static const int16_t kSbInt16Min = ((int16_t)0x8000);
static const int16_t kSbInt16Max = ((int16_t)0x7FFF);
static const uint16_t kSbUInt16Max = ((uint16_t)0xFFFF);

#define kSbInt32Min ((int32_t)0x80000000)
static const int32_t kSbInt32Max = ((int32_t)0x7FFFFFFF);
static const uint32_t kSbUInt32Max = ((uint32_t)0xFFFFFFFF);

static const int64_t kSbInt64Min = ((int64_t)SB_INT64_C(0x8000000000000000));
static const int64_t kSbInt64Max = ((int64_t)SB_INT64_C(0x7FFFFFFFFFFFFFFF));
static const uint64_t kSbUInt64Max = ((uint64_t)SB_INT64_C(0xFFFFFFFFFFFFFFFF));

#if defined(_MSC_VER)
#pragma warning(pop)
#endif

// A value that represents an int that is probably invalid.
#define kSbInvalidInt kSbInt32Min

#if !SB_HAS(FLOAT_H)
#define DBL_MANT_DIG 53
#endif

// --- Standard Include Emulation Audits ---------------------------------------

#if !defined(UINT_MAX) || !defined(INT_MIN) || !defined(INT_MAX) || \
    !defined(LONG_MIN) || !defined(LONG_MAX)
#error "limits.h or emulation did not provide a needed limit macro."
#endif

#if (UINT_MIN + 1 == UINT_MAX - 1) || (INT_MIN + 1 == INT_MAX - 1) || \
    (LONG_MIN + 1 == LONG_MAX - 1)
// This should always evaluate to false, but ensures that the limits macros can
// be used arithmetically in the preprocessor.
#endif

#if !defined(PRId32)
#error "inttypes.h should provide the portable formatting macros."
#endif

// --- Standard Type Audits ----------------------------------------------------

#if SB_IS(WCHAR_T_UTF16)
SB_COMPILE_ASSERT(sizeof(wchar_t) == 2,
                  SB_IS_WCHAR_T_UTF16_is_inconsistent_with_sizeof_wchar_t);
#endif

#if SB_IS(WCHAR_T_UTF32)
SB_COMPILE_ASSERT(sizeof(wchar_t) == 4,
                  SB_IS_WCHAR_T_UTF32_is_inconsistent_with_sizeof_wchar_t);
#endif

#if SB_IS(WCHAR_T_SIGNED)
SB_COMPILE_ASSERT((wchar_t)(-1) < 0,
                  SB_IS_WCHAR_T_SIGNED_is_defined_incorrectly);
#endif

#if SB_IS(WCHAR_T_UNSIGNED)
SB_COMPILE_ASSERT((wchar_t)(-1) > 0,
                  SB_IS_WCHAR_T_UNSIGNED_is_defined_incorrectly);
#endif

#ifdef __cplusplus
}  // extern "C"
#endif

#endif  // STARBOARD_TYPES_H_