1082 lines
41 KiB
C
1082 lines
41 KiB
C
/*****************************************************************************/
|
|
/* SISCO SOFTWARE MODULE HEADER **********************************************/
|
|
/*****************************************************************************/
|
|
/* (c) Copyright Systems Integration Specialists Company, Inc., */
|
|
/* 2005 All Rights Reserved */
|
|
/* */
|
|
/* MODULE NAME : QuadLib.h */
|
|
/* PRODUCT(S) : Standard Time Management Library */
|
|
/* */
|
|
/* MODULE DESCRIPTION: */
|
|
/* 64-bit Math Simulation Library - header file */
|
|
/* Provided for platforms without native 64-bit support. */
|
|
/* */
|
|
/* When QUADLIB_ENABLED is defined, definitions relevant to the */
|
|
/* simulations library are generated. Otherwise, definitions are */
|
|
/* selected to develop code on 64-bit enabled platforms without going */
|
|
/* through the QuadLib library. */
|
|
/* */
|
|
/* Define QUADLIB_STATIC as 'static' to make the declarations local. */
|
|
/* */
|
|
/* Define QUADLIB_I64N as the native signed 64-bit data type. */
|
|
/* Define QUADLIB_U64N as the native unsigned 64-bit data type. */
|
|
/* If not defined, an assumption is made based on existence of _WIN32. */
|
|
/* */
|
|
/* The include file "host_endian.h" defines the native host endian order. */
|
|
/* */
|
|
/* MODIFICATION LOG: */
|
|
/* Date Who Rev Comments */
|
|
/* -------- --- --- ----------------------------------------------------- */
|
|
/* 02/22/08 JRB 03 Use SD_BYTE_ORDER like all other SISCO code. */
|
|
/* 06/07/06 RLH 02 Numerous features added, see stdtime.doc */
|
|
/* 01/18/06 RLH 01 Created */
|
|
/*****************************************************************************/
|
|
|
|
|
|
#ifndef _STDTIME_QUADLIB_H_B07CB807_8BFC_41B3_872E_EDD251FD6AEB_
|
|
#define _STDTIME_QUADLIB_H_B07CB807_8BFC_41B3_872E_EDD251FD6AEB_
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
/* ENABLED or DISABLED: SUPPORT FOR 64-BIT EMULATION */
|
|
/* */
|
|
/* use StdTimeConfig.h to set QUADLIB_ENABLED or QUADLIB_DISABLED */
|
|
/*****************************************************************************/
|
|
|
|
#if defined(QUADLIB_ENABLED) && defined(QUADLIB_DISABLED)
|
|
#error Both QUADLIB_ENABLED and QUADLIB_DISABLED defined
|
|
#undef QUADLIB_ENABLED
|
|
#endif
|
|
|
|
#if !defined(QUADLIB_ENABLED) && !defined(QUADLIB_DISABLED)
|
|
#define QUADLIB_DISABLED /* default */
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
/* ENABLED or DISABLED: EXISTENCE OF 64-BIT SUPPORT IN COMPILER */
|
|
/* */
|
|
/* use StdTimeConfig.h to set QUADLIB_NATIVE64_ENABLED or */
|
|
/* QUADLIB_NATIVE64_DISABLED */
|
|
/*****************************************************************************/
|
|
|
|
/* these defines are used mainly to avoid compile errors on platforms */
|
|
/* that have no support at all for 64-bit types */
|
|
|
|
#if defined(QUADLIB_NATIVE64_ENABLED) && defined(QUADLIB_NATIVE64_DISABLED)
|
|
#error Both QUADLIB_NATIVE64_ENABLED and QUADLIB_NATIVE64_DISABLED defined
|
|
#undef QUADLIB_NATIVE64_ENABLED
|
|
#undef QUADLIB_NATIVE64_DISABLED
|
|
#endif
|
|
|
|
#if !defined(QUADLIB_NATIVE64_ENABLED) && !defined(QUADLIB_NATIVE64_DISABLED)
|
|
#ifdef _WIN32
|
|
#define QUADLIB_NATIVE64_ENABLED
|
|
#else
|
|
#define QUADLIB_NATIVE64_DISABLED
|
|
#endif
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
/* VALIDATE NATIVE SUPPORT VS. EMULATION SUPPORT */
|
|
/*****************************************************************************/
|
|
|
|
/* either the host must support 64-bit mode or we must emulate it */
|
|
/* otherwise, the code that manages 64-bit FILETIME values will not work */
|
|
|
|
#if defined(QUADLIB_DISABLED) && defined(QUADLIB_NATIVE64_DISABLED)
|
|
#error QUADLIB_DISABLED and QUADLIB_NATIVE64_DISABLED, cannot generate code
|
|
#endif
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* STATIC (LOCAL) FUNCTION QUALIFIER */
|
|
/* */
|
|
/* use StdTimeConfig.h to set QUADLIB_STATIC */
|
|
/*****************************************************************************/
|
|
|
|
#ifndef QUADLIB_STATIC
|
|
#define QUADLIB_STATIC
|
|
#endif
|
|
|
|
/* stdtimeconfig.h includes appropriate stdint.h header for 32/64 bit types */
|
|
|
|
#define QUADLIB_U32_HIGHBIT 0x80000000
|
|
|
|
/*****************************************************************************/
|
|
/* NATIVE 64 BIT TYPES */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_NATIVE64_ENABLED
|
|
#define QUADLIB_I64N int64_t
|
|
#define QUADLIB_U64N uint64_t
|
|
|
|
#else /* not QUADLIB_NATIVE64_ENABLED */
|
|
|
|
/* host has NO 64-bit data types */
|
|
/* the following defines are just for compatibility */
|
|
/* but lack 64-bit capacity. _WIN32 always supports I64 */
|
|
/* so this is just a non-Windows issue. */
|
|
|
|
#ifndef QUADLIB_I64N
|
|
#define QUADLIB_I64N int32_t /* 32-bit */
|
|
#endif
|
|
|
|
#ifndef QUADLIB_U64N
|
|
#define QUADLIB_U64N uint32_t /* 32-bit */
|
|
#endif
|
|
|
|
#endif /* QUADLIB_NATIVE64_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* QUADLIB_I64 - hi/lo member ordering based on ENDIAN definition above */
|
|
/* QUADLIB_U64 has the same representation as QUADLIB_I64 */
|
|
/* two names are used mainly to document the intended usage */
|
|
/*****************************************************************************/
|
|
|
|
/* Make sure SD_BYTE_ORDER is defined (in glbtypes.h) */
|
|
#if !defined(SD_BYTE_ORDER)
|
|
#error SD_BYTE_ORDER not defined
|
|
#endif
|
|
#if (SD_BYTE_ORDER==SD_LITTLE_ENDIAN)
|
|
|
|
typedef struct
|
|
{
|
|
union
|
|
{
|
|
int32_t i;
|
|
uint32_t u;
|
|
} lo;
|
|
|
|
union
|
|
{
|
|
int32_t i;
|
|
uint32_t u;
|
|
} hi;
|
|
}
|
|
QUADLIB_I64_TYPE;
|
|
|
|
#else /* BIG_ENDIAN */
|
|
|
|
typedef struct
|
|
{
|
|
union
|
|
{
|
|
int32_t i;
|
|
uint32_t u;
|
|
} hi;
|
|
|
|
union
|
|
{
|
|
int32_t i;
|
|
uint32_t u;
|
|
} lo;
|
|
}
|
|
QUADLIB_I64_TYPE;
|
|
|
|
#endif /* BIG_ENDIAN */
|
|
|
|
#define QUADLIB_U64_TYPE QUADLIB_I64_TYPE
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
/* enabled means 64-bit operations are simulated in software */
|
|
|
|
#define QUADLIB_I64 QUADLIB_I64_TYPE
|
|
#define QUADLIB_U64 QUADLIB_I64_TYPE
|
|
#define QUADLIB_ZERO {0,0}
|
|
#define QUADLIB_U64_MAX {0xFFFFFFFF, 0xFFFFFFFF}
|
|
|
|
#if (SD_BYTE_ORDER==SD_LITTLE_ENDIAN)
|
|
|
|
#define QUADLIB_I64_MAX {0xFFFFFFFF, 0x7FFFFFFF}
|
|
#define QUADLIB_I64_MIN {0x00000000, 0x80000000}
|
|
|
|
#else /* BIG_ENDIAN */
|
|
|
|
#define QUADLIB_I64_MAX {0x7FFFFFFF, 0xFFFFFFFF}
|
|
#define QUADLIB_I64_MIN {0x00000000, 0x00000000}
|
|
|
|
#endif /* BIG_ENDIAN */
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
/* use native 64-bit values for a few compatibility functions */
|
|
|
|
#define QUADLIB_I64 QUADLIB_I64N
|
|
#define QUADLIB_U64 QUADLIB_U64N
|
|
#define QUADLIB_ZERO 0
|
|
#define QUADLIB_U64_MAX (QUADLIB_U64)0xFFFFFFFFFFFFFFFF
|
|
#define QUADLIB_I64_MAX (QUADLIB_I64)0x7FFFFFFFFFFFFFFF
|
|
#define QUADLIB_I64_MIN (QUADLIB_I64)0x8000000000000000
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
|
|
#ifdef _WCHAR_T_DEFINED
|
|
typedef wchar_t QUADLIB_WCHAR;
|
|
#else
|
|
typedef unsigned short QUADLIB_WCHAR;
|
|
#endif
|
|
|
|
#define QUADLIB_STRING_LEN 20
|
|
|
|
|
|
typedef struct
|
|
{
|
|
char str [QUADLIB_STRING_LEN+1];
|
|
}
|
|
QUADLIB_STRINGA;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
QUADLIB_WCHAR str [QUADLIB_STRING_LEN+1];
|
|
}
|
|
QUADLIB_STRINGW;
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* NOT */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_NOT(x) QuadLibI64Not(x)
|
|
#define QUADLIB_U64_NOT(x) QuadLibU64Not(x)
|
|
|
|
#define QuadLibI64Not(x) QuadLibU64Not(x)
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Not (QUADLIB_U64 x);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_NOT(x) (~x)
|
|
#define QUADLIB_U64_NOT(x) (~x)
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* AND */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_AND(x,y) QuadLibI64And(x,y)
|
|
#define QUADLIB_U64_AND(x,y) QuadLibU64And(x,y)
|
|
#define QUADLIB_I64_AND_EQ(x,y) x = QuadLibI64And(x,y)
|
|
#define QUADLIB_U64_AND_EQ(x,y) x = QuadLibU64And(x,y)
|
|
|
|
#define QUADLIB_I64_ANDNOT(x,y) QuadLibI64AndNot(x,y)
|
|
#define QUADLIB_U64_ANDNOT(x,y) QuadLibU64AndNot(x,y)
|
|
#define QUADLIB_I64_ANDNOT_EQ(x,y) x = QuadLibI64AndNot(x,y)
|
|
#define QUADLIB_U64_ANDNOT_EQ(x,y) x = QuadLibU64AndNot(x,y)
|
|
|
|
#define QuadLibI64And(x,y) QuadLibU64And(x,y)
|
|
#define QuadLibI64AndNot(x) QuadLibU64AndNot(x)
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64And (
|
|
QUADLIB_U64 /*I*/ one,
|
|
QUADLIB_U64 /*I*/ two);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64AndNot (
|
|
QUADLIB_U64 /*I*/ one,
|
|
QUADLIB_U64 /*I*/ two);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_AND(x,y) (x & y)
|
|
#define QUADLIB_U64_AND(x,y) (x & y)
|
|
#define QUADLIB_I64_AND_EQ(x,y) x &= y
|
|
#define QUADLIB_U64_AND_EQ(x,y) x &= y
|
|
|
|
#define QUADLIB_I64_ANDNOT(x,y) (x & (~y))
|
|
#define QUADLIB_U64_ANDNOT(x,y) (x & (~y))
|
|
#define QUADLIB_I64_ANDNOT_EQ(x,y) x = x & (~y)
|
|
#define QUADLIB_U64_ANDNOT_EQ(x,y) x = x & (~y)
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* OR */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_OR(x,y) QuadLibI64Or(x,y)
|
|
#define QUADLIB_U64_OR(x,y) QuadLibU64Or(x,y)
|
|
#define QUADLIB_I64_OR_EQ(x,y) x = QuadLibI64Or(x,y)
|
|
#define QUADLIB_U64_OR_EQ(x,y) x = QuadLibU64Or(x,y)
|
|
|
|
#define QUADLIB_I64_ORNOT(x,y) QuadLibI64OrNot(x,y)
|
|
#define QUADLIB_U64_ORNOT(x,y) QuadLibU64OrNot(x,y)
|
|
#define QUADLIB_I64_ORNOT_EQ(x,y) x = QuadLibI64OrNot(x,y)
|
|
#define QUADLIB_U64_ORNOT_EQ(x,y) x = QuadLibU64OrNot(x,y)
|
|
|
|
#define QuadLibI64Or(x,y) QuadLibU64Or(x,y)
|
|
#define QuadLibI64OrNot(x) QuadLibU64OrNot(x)
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Or (
|
|
QUADLIB_U64 /*I*/ one,
|
|
QUADLIB_U64 /*I*/ two);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64OrNot (
|
|
QUADLIB_U64 /*I*/ one,
|
|
QUADLIB_U64 /*I*/ two);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_OR(x,y) (x | y)
|
|
#define QUADLIB_U64_OR(x,y) (x | y)
|
|
#define QUADLIB_I64_OR_EQ(x,y) x |= y
|
|
#define QUADLIB_U64_OR_EQ(x,y) x |= y
|
|
|
|
#define QUADLIB_I64_ORNOT(x,y) (x | (~y))
|
|
#define QUADLIB_U64_ORNOT(x,y) (x | (~y))
|
|
#define QUADLIB_I64_ORNOT_EQ(x,y) x = x | (~y)
|
|
#define QUADLIB_U64_ORNOT_EQ(x,y) x = x | (~y)
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* XOR */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_XOR(x,y) QuadLibI64Xor(x,y)
|
|
#define QUADLIB_U64_XOR(x,y) QuadLibU64Xor(x,y)
|
|
#define QUADLIB_I64_XOR_EQ(x,y) x = QuadLibI64Xor(x,y)
|
|
#define QUADLIB_U64_XOR_EQ(x,y) x = QuadLibU64Xor(x,y)
|
|
|
|
#define QUADLIB_I64_XORNOT(x,y) QuadLibI64XorNot(x,y)
|
|
#define QUADLIB_U64_XORNOT(x,y) QuadLibU64XorNot(x,y)
|
|
#define QUADLIB_I64_XORNOT_EQ(x,y) x = QuadLibI64XorNot(x,y)
|
|
#define QUADLIB_U64_XORNOT_EQ(x,y) x = QuadLibU64XorNot(x,y)
|
|
|
|
#define QuadLibI64Xor(x,y) QuadLibU64Xor(x,y)
|
|
#define QuadLibI64XorNot(x) QuadLibU64XorNot(x)
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Xor (
|
|
QUADLIB_U64 /*I*/ one,
|
|
QUADLIB_U64 /*I*/ two);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64XorNot (
|
|
QUADLIB_U64 /*I*/ one,
|
|
QUADLIB_U64 /*I*/ two);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_XOR(x,y) (x ^ y)
|
|
#define QUADLIB_U64_XOR(x,y) (x ^ y)
|
|
#define QUADLIB_I64_XOR_EQ(x,y) x ^= y
|
|
#define QUADLIB_U64_XOR_EQ(x,y) x ^= y
|
|
|
|
#define QUADLIB_I64_XORNOT(x,y) (x ^ (~y))
|
|
#define QUADLIB_U64_XORNOT(x,y) (x ^ (~y))
|
|
#define QUADLIB_I64_XORNOT_EQ(x,y) x = x ^ (~y)
|
|
#define QUADLIB_U64_XORNOT_EQ(x,y) x = x ^ (~y)
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* ADD */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_ADD(x,y) QuadLibI64Add(x,y)
|
|
#define QUADLIB_U64_ADD(x,y) QuadLibU64Add(x,y)
|
|
#define QUADLIB_I64_ADD_EQ(x,y) x = QuadLibI64Add(x,y)
|
|
#define QUADLIB_U64_ADD_EQ(x,y) x = QuadLibU64Add(x,y)
|
|
|
|
#define QUADLIB_I64_ADD1(x) QuadLibI64Add1(x)
|
|
#define QUADLIB_U64_ADD1(x) QuadLibU64Add1(x)
|
|
#define QUADLIB_I64_ADD1_EQ(x) x = QuadLibI64Add1(x)
|
|
#define QUADLIB_U64_ADD1_EQ(x) x = QuadLibU64Add1(x)
|
|
|
|
#define QuadLibI64Add(x,y) QuadLibU64Add(x,y)
|
|
#define QuadLibI64Add1(x) QuadLibU64Add1(x)
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Add (
|
|
QUADLIB_U64 /*I*/ one,
|
|
QUADLIB_U64 /*I*/ two);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Add1 (
|
|
QUADLIB_U64 /*I*/ x);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_ADD(x,y) (x + y)
|
|
#define QUADLIB_U64_ADD(x,y) (x + y)
|
|
#define QUADLIB_I64_ADD_EQ(x,y) x += y
|
|
#define QUADLIB_U64_ADD_EQ(x,y) x += y
|
|
|
|
#define QUADLIB_I64_ADD1(x) (x + y)
|
|
#define QUADLIB_U64_ADD1(x) (x + y)
|
|
#define QUADLIB_I64_ADD1_EQ(x) x++
|
|
#define QUADLIB_U64_ADD1_EQ(x) x++
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* SUB */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_SUB(x,y) QuadLibI64Sub(x,y)
|
|
#define QUADLIB_U64_SUB(x,y) QuadLibU64Sub(x,y)
|
|
#define QUADLIB_I64_SUB_EQ(x,y) x = QuadLibI64Sub(x,y)
|
|
#define QUADLIB_U64_SUB_EQ(x,y) x = QuadLibU64Sub(x,y)
|
|
|
|
#define QUADLIB_I64_SUB1(x) QuadLibI64Sub1(x)
|
|
#define QUADLIB_U64_SUB1(x) QuadLibU64Sub1(x)
|
|
#define QUADLIB_I64_SUB1_EQ(x) x = QuadLibI64Sub1(x)
|
|
#define QUADLIB_U64_SUB1_EQ(x) x = QuadLibU64Sub1(x)
|
|
|
|
#define QuadLibI64Sub(x,y) QuadLibU64Sub(x,y)
|
|
#define QuadLibI64Sub1(x) QuadLibU64Sub1(x)
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Sub (
|
|
QUADLIB_U64 /*I*/ one,
|
|
QUADLIB_U64 /*I*/ two);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Sub1 (
|
|
QUADLIB_U64 /*I*/ x);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_SUB(x,y) (x - y)
|
|
#define QUADLIB_U64_SUB(x,y) (x - y)
|
|
#define QUADLIB_I64_SUB_EQ(x,y) x -= y
|
|
#define QUADLIB_U64_SUB_EQ(x,y) x -= y
|
|
|
|
#define QUADLIB_I64_SUB1(x) (x - y)
|
|
#define QUADLIB_U64_SUB1(x) (x - y)
|
|
#define QUADLIB_I64_SUB1_EQ(x) x--
|
|
#define QUADLIB_U64_SUB1_EQ(x) x--
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* NEG */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_NEG(x) QuadLibI64Neg(x)
|
|
#define QUADLIB_U64_NEG(x) QuadLibU64Neg(x)
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Neg (QUADLIB_U64 x);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_NEG(x) (-x)
|
|
#define QUADLIB_U64_NEG(x) (-x)
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
#define QuadLibI64Neg(x) QuadLibU64Neg(x)
|
|
|
|
/*****************************************************************************/
|
|
/* ABS */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_ABS(x) QuadLibI64Abs(x)
|
|
#define QUADLIB_U64_ABS(x) QuadLibU64Abs(x)
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_ABS(x) ((x) >= 0 ? (x) : -(x))
|
|
#define QUADLIB_U64_ABS(x) ((x) >= 0 ? (x) : -(x))
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
#define QuadLibI64Abs(x) QuadLibU64Abs(x)
|
|
|
|
/* quad abs function always defined */
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Abs (QUADLIB_U64 x);
|
|
|
|
/*****************************************************************************/
|
|
/* CMP */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_EQ(x,y) QuadLibI64EQ(x,y)
|
|
#define QUADLIB_I64_NE(x,y) QuadLibI64NE(x,y)
|
|
#define QUADLIB_I64_GT(x,y) QuadLibI64GT(x,y)
|
|
#define QUADLIB_I64_GE(x,y) QuadLibI64GE(x,y)
|
|
#define QUADLIB_I64_LT(x,y) QuadLibI64LT(x,y)
|
|
#define QUADLIB_I64_LE(x,y) QuadLibI64LE(x,y)
|
|
|
|
#define QUADLIB_U64_EQ(x,y) QuadLibU64EQ(x,y)
|
|
#define QUADLIB_U64_NE(x,y) QuadLibU64NE(x,y)
|
|
#define QUADLIB_U64_GT(x,y) QuadLibU64GT(x,y)
|
|
#define QUADLIB_U64_GE(x,y) QuadLibU64GE(x,y)
|
|
#define QUADLIB_U64_LT(x,y) QuadLibU64LT(x,y)
|
|
#define QUADLIB_U64_LE(x,y) QuadLibU64LE(x,y)
|
|
|
|
#define QuadLibI64EQ(x,y) (QuadLibI64Cmp(x,y)==0)
|
|
#define QuadLibI64NE(x,y) (QuadLibI64Cmp(x,y)!=0)
|
|
#define QuadLibI64GT(x,y) (QuadLibI64Cmp(x,y)> 0)
|
|
#define QuadLibI64GE(x,y) (QuadLibI64Cmp(x,y)>=0)
|
|
#define QuadLibI64LT(x,y) (QuadLibI64Cmp(x,y)< 0)
|
|
#define QuadLibI64LE(x,y) (QuadLibI64Cmp(x,y)<=0)
|
|
|
|
#define QuadLibU64EQ(x,y) (QuadLibU64Cmp(x,y)==0)
|
|
#define QuadLibU64NE(x,y) (QuadLibU64Cmp(x,y)!=0)
|
|
#define QuadLibU64GT(x,y) (QuadLibU64Cmp(x,y)> 0)
|
|
#define QuadLibU64GE(x,y) (QuadLibU64Cmp(x,y)>=0)
|
|
#define QuadLibU64LT(x,y) (QuadLibU64Cmp(x,y)< 0)
|
|
#define QuadLibU64LE(x,y) (QuadLibU64Cmp(x,y)<=0)
|
|
|
|
QUADLIB_STATIC int32_t QuadLibU64Cmp (
|
|
/*I*/ QUADLIB_U64 x,
|
|
/*I*/ QUADLIB_U64 y);
|
|
|
|
QUADLIB_STATIC int32_t QuadLibI64Cmp (
|
|
/*I*/ QUADLIB_I64 x,
|
|
/*I*/ QUADLIB_I64 y);
|
|
|
|
#define QUADLIB_I64_EQ_0(x) (! QUADLIB_I64_NE_0(x))
|
|
#define QUADLIB_I64_NE_0(x) (QUADLIB_U64_HI(x) | QUADLIB_U64_LO(x))
|
|
#define QUADLIB_I64_GT_0(x) (QUADLIB_I64_GE_0(x) && QUADLIB_I64_NE_0(x))
|
|
#define QUADLIB_I64_GE_0(x) (QUADLIB_I64_HI(x) >= 0)
|
|
#define QUADLIB_I64_LT_0(x) (QUADLIB_I64_HI(x) < 0)
|
|
#define QUADLIB_I64_LE_0(x) (QUADLIB_I64_LT_0(x) || QUADLIB_I64_EQ_0(x))
|
|
|
|
#define QUADLIB_U64_EQ_0(x) (! QUADLIB_U64_NE_0(x))
|
|
#define QUADLIB_U64_NE_0(x) (QUADLIB_U64_HI(x) | QUADLIB_U64_LO(x))
|
|
#define QUADLIB_U64_GT_0(x) (QUADLIB_U64_GE_0(x) && QUADLIB_U64_NE_0(x))
|
|
#define QUADLIB_U64_GE_0(x) (QUADLIB_U64_HI(x) >= 0)
|
|
|
|
#if 0
|
|
#define QUADLIB_U64_LT_0(x) (QUADLIB_U64_HI(x) < 0)
|
|
#define QUADLIB_U64_LE_0(x) (QUADLIB_U64_LT_0(x) || QUADLIB_U64_EQ_0(x))
|
|
#endif
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_EQ(x,y) ((x) == (y))
|
|
#define QUADLIB_I64_NE(x,y) ((x) != (y))
|
|
#define QUADLIB_I64_GT(x,y) ((x) > (y))
|
|
#define QUADLIB_I64_GE(x,y) ((x) >= (y))
|
|
#define QUADLIB_I64_LT(x,y) ((x) < (y))
|
|
#define QUADLIB_I64_LE(x,y) ((x) <= (y))
|
|
|
|
#define QUADLIB_U64_EQ(x,y) ((x) == (y))
|
|
#define QUADLIB_U64_NE(x,y) ((x) != (y))
|
|
#define QUADLIB_U64_GT(x,y) ((x) > (y))
|
|
#define QUADLIB_U64_GE(x,y) ((x) >= (y))
|
|
#define QUADLIB_U64_LT(x,y) ((x) < (y))
|
|
#define QUADLIB_U64_LE(x,y) ((x) <= (y))
|
|
|
|
#define QUADLIB_I64_EQ_0(x) ((x) == 0)
|
|
#define QUADLIB_I64_NE_0(x) ((x) != 0)
|
|
#define QUADLIB_I64_GT_0(x) ((x) > 0)
|
|
#define QUADLIB_I64_GE_0(x) ((x) >= 0)
|
|
#define QUADLIB_I64_LT_0(x) ((x) < 0)
|
|
#define QUADLIB_I64_LE_0(x) ((x) <= 0)
|
|
|
|
#define QUADLIB_U64_EQ_0(x) ((x) == 0)
|
|
#define QUADLIB_U64_NE_0(x) ((x) != 0)
|
|
#define QUADLIB_U64_GT_0(x) ((x) > 0)
|
|
#define QUADLIB_U64_GE_0(x) ((x) >= 0)
|
|
|
|
#if 0
|
|
#define QUADLIB_U64_LT_0(x) ((x) < 0)
|
|
#define QUADLIB_U64_LE_0(x) ((x) <= 0)
|
|
#endif
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* I32 OVERFLOW CHECK */
|
|
/*****************************************************************************/
|
|
|
|
|
|
#define QUADLIB_I64_NOT_OVERFLOW_I32(x) \
|
|
( ((QUADLIB_I64_HI(x) == 0) && (QUADLIB_I64_LO(x) >= 0)) \
|
|
|| ((QUADLIB_I64_HI(x) == -1) && (QUADLIB_I64_LO(x) < 0)) ) /**/
|
|
|
|
|
|
#define QUADLIB_I64_OVERFLOW_I32(x) (! QUADLIB_I64_NOT_OVERFLOW_I32(x))
|
|
|
|
|
|
#define QUADLIB_U64_NOT_OVERFLOW_I32(x) \
|
|
((QUADLIB_I64_HI(x) == 0) && (QUADLIB_I64_LO(x) >= 0)) /**/
|
|
|
|
|
|
#define QUADLIB_U64_OVERFLOW_I32(x) (! QUADLIB_U64_NOT_OVERFLOW_I32(x))
|
|
|
|
|
|
#define QUADLIB_I64_OVERFLOW_U32(x) (QUADLIB_I64_HI(x) != 0)
|
|
#define QUADLIB_U64_OVERFLOW_U32(x) (QUADLIB_I64_HI(x) != 0)
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* SHL */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_SHL(x,n) QuadLibU64SHL(x,n)
|
|
#define QUADLIB_U64_SHL(x,n) QuadLibU64SHL(x,n)
|
|
|
|
#define QUADLIB_I64_SHL1(x) QuadLibU64SHL1(x)
|
|
#define QUADLIB_U64_SHL1(x) QuadLibU64SHL1(x)
|
|
|
|
#define QUADLIB_I64_SHL4(x) QuadLibU64SHL4(x)
|
|
#define QUADLIB_U64_SHL4(x) QuadLibU64SHL4(x)
|
|
|
|
#define QUADLIB_I64_SHL_EQ(x,n) x = QUADLIB_I64_SHL(x,n)
|
|
#define QUADLIB_U64_SHL_EQ(x,n) x = QUADLIB_U64_SHL(x,n)
|
|
|
|
#define QUADLIB_I64_SHL1_EQ(x) x = QUADLIB_I64_SHL1(x)
|
|
#define QUADLIB_U64_SHL1_EQ(x) x = QUADLIB_U64_SHL1(x)
|
|
|
|
#define QUADLIB_I64_SHL4_EQ(x) x = QUADLIB_I64_SHL4(x)
|
|
#define QUADLIB_U64_SHL4_EQ(x) x = QUADLIB_U64_SHL4(x)
|
|
|
|
#define QUADLIB_I64_SHL1_EQ_INLINE(x) QUADLIB_U64_SHL1_EQ_INLINE(x)
|
|
|
|
|
|
#define QUADLIB_U64_SHL1_EQ_INLINE(x) \
|
|
{ \
|
|
x.hi.u <<= 1; \
|
|
if (x.lo.i < 0) \
|
|
{ \
|
|
x.hi.u++; \
|
|
} \
|
|
x.lo.u <<= 1; \
|
|
} /**/
|
|
|
|
|
|
#define QUADLIB_I64_SHL4_EQ_INLINE(x) QUADLIB_U64_SHL4_EQ_INLINE(x)
|
|
|
|
|
|
#define QUADLIB_U64_SHL4_EQ_INLINE(x) \
|
|
{ \
|
|
x.hi.u = (x.hi.u << 4) | (x.lo.u >> 28); \
|
|
x.lo.u <<= 4; \
|
|
} /**/
|
|
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64SHL (
|
|
QUADLIB_U64 /*I*/ value,
|
|
int32_t /*I*/ shift);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64SHL1 (
|
|
QUADLIB_U64 /*I*/ value);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64SHL4 (
|
|
QUADLIB_U64 /*I*/ value);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_SHL(x,n) ((x) << n)
|
|
#define QUADLIB_U64_SHL(x,n) ((x) << n)
|
|
|
|
#define QUADLIB_I64_SHL1(x) ((x) << 1)
|
|
#define QUADLIB_U64_SHL1(x) ((x) << 1)
|
|
|
|
#define QUADLIB_I64_SHL4(x) ((x) << 4)
|
|
#define QUADLIB_U64_SHL4(x) ((x) << 4)
|
|
|
|
#define QUADLIB_I64_SHL_EQ(x,n) x = ((x) << n)
|
|
#define QUADLIB_U64_SHL_EQ(x,n) x = ((x) << n)
|
|
|
|
#define QUADLIB_I64_SHL1_EQ(x) x <<= 1
|
|
#define QUADLIB_U64_SHL1_EQ(x) x <<= 1
|
|
|
|
#define QUADLIB_I64_SHL1_EQ_INLINE(x) QUADLIB_I64_SHL1_EQ(x)
|
|
#define QUADLIB_U64_SHL1_EQ_INLINE(x) QUADLIB_U64_SHL1_EQ(x)
|
|
|
|
#define QUADLIB_I64_SHL4_EQ(x) x <<= 4
|
|
#define QUADLIB_U64_SHL4_EQ(x) x <<= 4
|
|
|
|
#define QUADLIB_I64_SHL4_EQ_INLINE(x) QUADLIB_I64_SHL4_EQ(x)
|
|
#define QUADLIB_U64_SHL4_EQ_INLINE(x) QUADLIB_U64_SHL4_EQ(x)
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* SHR */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_SHR(x,n) QuadLibI64SHR(x,n)
|
|
#define QUADLIB_U64_SHR(x,n) QuadLibU64SHR(x,n)
|
|
|
|
#define QUADLIB_I64_SHR1(x) QuadLibI64SHR1(x)
|
|
#define QUADLIB_U64_SHR1(x) QuadLibU64SHR1(x)
|
|
|
|
#define QUADLIB_I64_SHR4(x) QuadLibI64SHR4(x)
|
|
#define QUADLIB_U64_SHR4(x) QuadLibU64SHR4(x)
|
|
|
|
#define QUADLIB_I64_SHR_EQ(x,n) x = QUADLIB_I64_SHR(x,n)
|
|
#define QUADLIB_U64_SHR_EQ(x,n) x = QUADLIB_U64_SHR(x,n)
|
|
|
|
#define QUADLIB_I64_SHR1_EQ(x) x = QUADLIB_I64_SHR1(x)
|
|
#define QUADLIB_U64_SHR1_EQ(x) x = QUADLIB_U64_SHR1(x)
|
|
|
|
#define QUADLIB_I64_SHR4_EQ(x) x = QUADLIB_I64_SHR4(x)
|
|
#define QUADLIB_U64_SHR4_EQ(x) x = QUADLIB_U64_SHR4(x)
|
|
|
|
|
|
#define QUADLIB_I64_SHR1_EQ_INLINE(x) \
|
|
{ \
|
|
x.lo.u >>= 1; \
|
|
if (x.hi.u & 1) \
|
|
{ \
|
|
x.lo.u |= QUADLIB_U32_HIGHBIT; \
|
|
} \
|
|
x.hi.i >>= 1; /* signed */ \
|
|
} /**/
|
|
|
|
|
|
#define QUADLIB_U64_SHR1_EQ_INLINE(x) \
|
|
{ \
|
|
x.lo.u >>= 1; \
|
|
if (x.hi.u & 1) \
|
|
{ \
|
|
x.lo.u |= QUADLIB_U32_HIGHBIT; \
|
|
} \
|
|
x.hi.u >>= 1; /* unsigned */ \
|
|
} /**/
|
|
|
|
|
|
#define QUADLIB_I64_SHR4_EQ_INLINE(x) \
|
|
{ \
|
|
x.lo.u = (x.lo.u >> 4) | (x.hi.u << 28); \
|
|
x.hi.i >>= 4; /* signed */ \
|
|
} /**/
|
|
|
|
|
|
#define QUADLIB_U64_SHR4_EQ_INLINE(x) \
|
|
{ \
|
|
x.lo.u = (x.lo.u >> 4) | (x.hi.u << 28); \
|
|
x.hi.u >>= 4; /* unsigned */ \
|
|
} /**/
|
|
|
|
|
|
QUADLIB_STATIC QUADLIB_I64 QuadLibI64SHR (
|
|
QUADLIB_U64 /*I*/ value,
|
|
int32_t /*I*/ shift);
|
|
|
|
QUADLIB_STATIC QUADLIB_I64 QuadLibI64SHR1 (
|
|
QUADLIB_U64 /*I*/ value);
|
|
|
|
QUADLIB_STATIC QUADLIB_I64 QuadLibI64SHR4 (
|
|
QUADLIB_U64 /*I*/ value);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64SHR (
|
|
QUADLIB_U64 /*I*/ value,
|
|
int32_t /*I*/ shift);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64SHR1 (
|
|
QUADLIB_U64 /*I*/ value);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64SHR4 (
|
|
QUADLIB_U64 /*I*/ value);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_SHR(x,n) ((QUADLIB_I64)x) >> n
|
|
#define QUADLIB_U64_SHR(x,n) ((QUADLIB_U64)x) >> n
|
|
|
|
#define QUADLIB_I64_SHR1(x) ((QUADLIB_I64)x) >> 1
|
|
#define QUADLIB_U64_SHR1(x) ((QUADLIB_U64)x) >> 1
|
|
|
|
#define QUADLIB_I64_SHR4(x) ((QUADLIB_I64)x) >> 4
|
|
#define QUADLIB_U64_SHR4(x) ((QUADLIB_U64)x) >> 4
|
|
|
|
#define QUADLIB_I64_SHR_EQ(x,n) x = ((QUADLIB_I64)x) >> n
|
|
#define QUADLIB_U64_SHR_EQ(x,n) x = ((QUADLIB_U64)x) >> n
|
|
|
|
#define QUADLIB_I64_SHR1_EQ(x) x = ((QUADLIB_I64)x) >> 1
|
|
#define QUADLIB_U64_SHR1_EQ(x) x = ((QUADLIB_U64)x) >> 1
|
|
|
|
#define QUADLIB_I64_SHR4_EQ(x) x = ((QUADLIB_I64)x) >> 4
|
|
#define QUADLIB_U64_SHR4_EQ(x) x = ((QUADLIB_U64)x) >> 4
|
|
|
|
#define QUADLIB_I64_SHR1_EQ_INLINE(x) QUADLIB_I64_SHR1_EQ(x)
|
|
#define QUADLIB_U64_SHR1_EQ_INLINE(x) QUADLIB_U64_SHR1_EQ(x)
|
|
|
|
#define QUADLIB_I64_SHR4_EQ_INLINE(x) QUADLIB_I64_SHR4_EQ(x)
|
|
#define QUADLIB_U64_SHR4_EQ_INLINE(x) QUADLIB_U64_SHR4_EQ(x)
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* CONVERT */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_CASTI64N(x) QuadLibI64CastI64N(&x,sizeof(x))
|
|
#define QUADLIB_U64_CASTU64N(x) QuadLibU64CastU64N(&x,sizeof(x))
|
|
|
|
QUADLIB_STATIC QUADLIB_I64 QuadLibI64CastI64N(void * x, size_t n);
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64CastU64N(void * x, size_t n);
|
|
|
|
#define QUADLIB_I64N_CASTI64(x) QuadLibI64NCastI64(x)
|
|
#define QUADLIB_U64N_CASTU64(x) QuadLibU64NCastU64(x)
|
|
|
|
QUADLIB_STATIC QUADLIB_I64N QuadLibI64NCastI64(QUADLIB_I64 x);
|
|
QUADLIB_STATIC QUADLIB_U64N QuadLibU64NCastU64(QUADLIB_U64 x);
|
|
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_CASTI64N(x) ((QUADLIB_I64)x)
|
|
#define QUADLIB_U64_CASTU64N(x) ((QUADLIB_U64)x)
|
|
#define QUADLIB_I64N_CASTI64(x) ((QUADLIB_I64N)x)
|
|
#define QUADLIB_U64N_CASTU64(x) ((QUADLIB_U64N)x)
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* CAST */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_CASTI32(x) QuadLibI64CastI32((int32_t)x)
|
|
#define QUADLIB_I64_CASTU32(x) QuadLibI64CastI32((uint32_t)x)
|
|
|
|
QUADLIB_STATIC QUADLIB_I64 QuadLibI64CastI32 (int32_t x);
|
|
|
|
#define QUADLIB_U64_CASTU32(x) QuadLibU64CastU32((uint32_t)x)
|
|
#define QUADLIB_U64_CASTI32(x) QuadLibU64CastU32((int32_t)x)
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64CastU32 (uint32_t x);
|
|
|
|
#define QUADLIB_I32_CASTI64(x) QuadLibI32CastI64(x)
|
|
#define QUADLIB_U32_CASTI64(x) ((QUADLIB_U64) QuadLibI32CastI64(x))
|
|
|
|
QUADLIB_STATIC int32_t QuadLibI32CastI64 (QUADLIB_I64 x);
|
|
|
|
#define QUADLIB_U32_CASTU64(x) QuadLibU32CastU64(x)
|
|
#define QUADLIB_I32_CASTU64(x) ((int32_t) QuadLibU32CastU64(x))
|
|
|
|
QUADLIB_STATIC uint32_t QuadLibU32CastU64 (QUADLIB_U64 x);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_CASTI32(x) ((QUADLIB_I64) (x))
|
|
#define QUADLIB_I64_CASTU32(x) ((QUADLIB_I64) (x))
|
|
|
|
#define QUADLIB_U64_CASTI32(x) ((QUADLIB_U64) (x))
|
|
#define QUADLIB_U64_CASTU32(x) ((QUADLIB_U64) (x))
|
|
|
|
#define QUADLIB_I32_CASTI64(x) ((int32_t) (x))
|
|
#define QUADLIB_I32_CASTU64(x) ((int32_t) (x))
|
|
|
|
#define QUADLIB_U32_CASTI64(x) ((uint32_t) (x))
|
|
#define QUADLIB_U32_CASTU64(x) ((uint32_t) (x))
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* GET/SET */
|
|
/*****************************************************************************/
|
|
|
|
#define QUADLIB_I64_HI(x) (*(QUADLIB_I64_TYPE *)(&x)).hi.i
|
|
#define QUADLIB_U64_HI(x) (*(QUADLIB_U64_TYPE *)(&x)).hi.u
|
|
#define QUADLIB_I64_LO(x) (*(QUADLIB_I64_TYPE *)(&x)).lo.i
|
|
#define QUADLIB_U64_LO(x) (*(QUADLIB_U64_TYPE *)(&x)).lo.u
|
|
|
|
#define FILETIME_TO_QUADLIB_I64 FILETIME_TO_QUADLIB_U64
|
|
|
|
|
|
#define FILETIME_TO_QUADLIB_U64(f,q) \
|
|
(*(QUADLIB_U64_TYPE *)(q)).lo.u = (f)->dwLowDateTime; \
|
|
(*(QUADLIB_U64_TYPE *)(q)).hi.u = (f)->dwHighDateTime /**/
|
|
|
|
|
|
#define QUADLIB_I64_TO_FILETIME QUADLIB_U64_TO_FILETIME
|
|
|
|
|
|
#define QUADLIB_U64_TO_FILETIME(q,f) \
|
|
(f)->dwLowDateTime = (*(QUADLIB_U64_TYPE *)(q)).lo.u; \
|
|
(f)->dwHighDateTime = (*(QUADLIB_U64_TYPE *)(q)).hi.u /**/
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* MUL */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_MUL(x,y) QuadLibI64Mul(x,y)
|
|
#define QUADLIB_U64_MUL(x,y) QuadLibU64Mul(x,y)
|
|
#define QUADLIB_I64_MUL_EQ(x,y) x = QuadLibI64Mul(x,y)
|
|
#define QUADLIB_U64_MUL_EQ(x,y) x = QuadLibU64Mul(x,y)
|
|
|
|
#define QUADLIB_I64_MUL10(x) QuadLibI64Mul10(x)
|
|
#define QUADLIB_U64_MUL10(x) QuadLibU64Mul10(x)
|
|
#define QUADLIB_I64_MUL10_EQ(x) x = QuadLibI64Mul10(x)
|
|
#define QUADLIB_U64_MUL10_EQ(x) x = QuadLibU64Mul10(x)
|
|
|
|
#define QuadLibI64Mul(x,y) QuadLibU64Mul(x,y)
|
|
#define QuadLibI64Mul10(x) QuadLibU64Mul10(x)
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Mul (
|
|
QUADLIB_U64 /*I*/ one,
|
|
QUADLIB_U64 /*I*/ two);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Mul10 (
|
|
QUADLIB_U64 /*I*/ x);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_MUL(x,y) (x * y)
|
|
#define QUADLIB_U64_MUL(x,y) (x * y)
|
|
#define QUADLIB_I64_MUL_EQ(x,y) x *= y
|
|
#define QUADLIB_U64_MUL_EQ(x,y) x *= y
|
|
|
|
#define QUADLIB_I64_MUL10(x) (x * ((QUADLIB_I64) 10))
|
|
#define QUADLIB_U64_MUL10(x) (x * ((QUADLIB_U64) 10))
|
|
#define QUADLIB_I64_MUL10_EQ(x) x *= ((QUADLIB_I64) 10)
|
|
#define QUADLIB_U64_MUL10_EQ(x) x *= ((QUADLIB_U64) 10)
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* STR TO I64/U64 */
|
|
/*****************************************************************************/
|
|
|
|
QUADLIB_STATIC QUADLIB_I64 StrAToQuadLibI64 (
|
|
char * /*I*/ str);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 StrAToQuadLibU64 (
|
|
char * /*I*/ str);
|
|
|
|
#ifdef QUADLIB_NATIVE64_ENABLED
|
|
|
|
#define QUADLIB_I64_NUM(x) (x)
|
|
#define QUADLIB_U64_NUM(x) (x)
|
|
|
|
#else /* not QUADLIB_NATIVE64_ENABLED */
|
|
|
|
#define QUADLIB_I64_NUM(x) StrAToQuadLibI64 (#x)
|
|
#define QUADLIB_U64_NUM(x) StrAToQuadLibU64 (#x)
|
|
|
|
#endif /* QUADLIB_NATIVE64_ENABLED */
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* I64/U64 TO STR */
|
|
/*****************************************************************************/
|
|
|
|
|
|
QUADLIB_STATIC void QuadLibU64ToFixedStrA (
|
|
QUADLIB_U64 /*I*/ qValue,
|
|
QUADLIB_STRINGA * /*O*/ pString);
|
|
|
|
|
|
QUADLIB_STATIC void QuadLibI64ToFixedStrA (
|
|
QUADLIB_I64 /*I*/ qValue,
|
|
QUADLIB_STRINGA * /*O*/ pString);
|
|
|
|
|
|
QUADLIB_STATIC void QuadLibU64ToStrA (
|
|
QUADLIB_U64 /*I*/ qValue,
|
|
QUADLIB_STRINGA * /*O*/ pString);
|
|
|
|
|
|
QUADLIB_STATIC void QuadLibI64ToStrA (
|
|
QUADLIB_I64 /*I*/ qValue,
|
|
QUADLIB_STRINGA * /*O*/ pString);
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* DIV/MOD */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef QUADLIB_ENABLED
|
|
|
|
#define QUADLIB_I64_DIV(x,y) QuadLibI64Div(x,y)
|
|
#define QUADLIB_U64_DIV(x,y) QuadLibU64Div(x,y)
|
|
#define QUADLIB_I64_DIV_EQ(x,y) x = QuadLibI64Div(x,y)
|
|
#define QUADLIB_U64_DIV_EQ(x,y) x = QuadLibU64Div(x,y)
|
|
|
|
#define QUADLIB_I64_MOD(x,y) QuadLibI64Mod(x,y)
|
|
#define QUADLIB_U64_MOD(x,y) QuadLibU64Mod(x,y)
|
|
#define QUADLIB_I64_MOD_EQ(x,y) x = QuadLibI64Mod(x,y)
|
|
#define QUADLIB_U64_MOD_EQ(x,y) x = QuadLibU64Mod(x,y)
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64DivMod (
|
|
QUADLIB_U64 u64Dividend,
|
|
QUADLIB_U64 u64Divisor,
|
|
QUADLIB_U64 *pu64Remainder);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Div (
|
|
QUADLIB_U64 u64Dividend,
|
|
QUADLIB_U64 u64Divisor);
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64Mod (
|
|
QUADLIB_U64 u64Dividend,
|
|
QUADLIB_U64 u64Divisor);
|
|
|
|
QUADLIB_STATIC QUADLIB_I64 QuadLibI64DivMod (
|
|
QUADLIB_I64 s64Dividend,
|
|
QUADLIB_I64 s64Divisor,
|
|
QUADLIB_I64 *ps64Remainder);
|
|
|
|
QUADLIB_STATIC QUADLIB_I64 QuadLibI64Div (
|
|
QUADLIB_I64 s64Dividend,
|
|
QUADLIB_I64 s64Divisor);
|
|
|
|
QUADLIB_STATIC QUADLIB_I64 QuadLibI64Mod (
|
|
QUADLIB_I64 s64Dividend,
|
|
QUADLIB_I64 s64Divisor);
|
|
|
|
#else /* not QUADLIB_ENABLED */
|
|
|
|
#define QUADLIB_I64_DIV(x,y) (x / y)
|
|
#define QUADLIB_U64_DIV(x,y) (x / y)
|
|
#define QUADLIB_I64_DIV_EQ(x,y) x /= y
|
|
#define QUADLIB_U64_DIV_EQ(x,y) x /= y
|
|
|
|
#define QUADLIB_I64_MOD(x,y) (x % y)
|
|
#define QUADLIB_U64_MOD(x,y) (x % y)
|
|
#define QUADLIB_I64_MOD_EQ(x,y) x %= y
|
|
#define QUADLIB_U64_MOD_EQ(x,y) x %= y
|
|
|
|
QUADLIB_STATIC QUADLIB_U64 QuadLibU64DivMod (
|
|
QUADLIB_U64 u64Dividend,
|
|
QUADLIB_U64 u64Divisor,
|
|
QUADLIB_U64 *pu64Remainder);
|
|
|
|
QUADLIB_STATIC QUADLIB_I64 QuadLibI64DivMod (
|
|
QUADLIB_I64 s64Dividend,
|
|
QUADLIB_I64 s64Divisor,
|
|
QUADLIB_I64 *ps64Remainder);
|
|
|
|
#endif /* QUADLIB_ENABLED */
|
|
|
|
/*****************************************************************************/
|
|
/* END */
|
|
/*****************************************************************************/
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
#endif /* _STDTIME_QUADLIB_H_B07CB807_8BFC_41B3_872E_EDD251FD6AEB_ */
|
|
|