/* File: Math64.h Contains: 64-bit integer math Interfaces. Version: QuickTime 7.3 Copyright: (c) 2007 (c) 1994-2001 by Apple Computer, Inc., all rights reserved Bugs?: For bug reports, consult the following page on the World Wide Web: http://developer.apple.com/bugreporter/ */ #ifndef __MATH64__ #define __MATH64__ #ifndef __CONDITIONALMACROS__ #include #endif #ifndef __MACTYPES__ #include #endif #if PRAGMA_ONCE #pragma once #endif #ifdef __cplusplus extern "C" { #endif #if PRAGMA_IMPORT #pragma import on #endif #if TYPE_LONGLONG && TARGET_OS_WIN32 #define S64Max() 9223372036854775807i64 #elif TYPE_LONGLONG && defined(__MWERKS__) && (__MWERKS__ < 0x1800) #define S64Max() 9223372036854775807 #else /* * S64Max() * * Discussion: * Returns largest possible SInt64 value * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64Max(void); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64Max(void) { return 9223372036854775807LL; } #else #define S64Max() (9223372036854775807LL) #endif #endif #endif /* * S64Min() * * Discussion: * Returns smallest possible SInt64 value * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64Min(void); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64Min(void) { return -S64Max() - 1; } #else #define S64Min() (-S64Max() - 1) #endif #endif /* * S64Add() * * Discussion: * Adds two integers, producing an integer result. If an overflow * occurs the result is congruent mod (2^64) as if the operands and * result were unsigned. No overflow is signaled. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64Add( SInt64 left, SInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64Add(SInt64 left, SInt64 right) { return (SInt64)(left) + (SInt64)(right); } #else #define S64Add(left, right) ((SInt64)(left) + (SInt64)(right)) #endif #endif /* * S64Subtract() * * Discussion: * Subtracts two integers, producing an integer result. If an * overflow occurs the result is congruent mod (2^64) as if the * operands and result were unsigned. No overflow is signaled. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64Subtract( SInt64 left, SInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64Subtract(SInt64 left, SInt64 right) { return (SInt64)(left) - (SInt64)(right); } #else #define S64Subtract(left, right) ((SInt64)(left) - (SInt64)(right)) #endif #endif /* * S64Negate() * * Discussion: * Returns the additive inverse of a signed number (i.e. it returns * 0 - the number). S64Negate (S64Min) is not representable (in * fact, it returns S64Min). * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64Negate(SInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64Negate(SInt64 value) { return -(SInt64)(value); } #else #define S64Negate(value) (-(SInt64)(value)) #endif #endif #if !TYPE_LONGLONG /* * S64Absolute() * * Discussion: * Returns the absolute value of the number (i.e. the number if it * is positive, or 0 - the number if it is negative). Disabled for * compilers that support long long until llabs() is available * everywhere. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64Absolute(SInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64Absolute(SInt64 value) { return llabs((SInt64)value); } #else #define S64Absolute(value) (llabs((SInt64)value)) #endif #endif #endif /* !TYPE_LONGLONG */ /* * S64Multiply() * * Discussion: * Multiplies two signed numbers, producing a signed result. * Overflow is ignored and the low-order part of the product is * returned. The sign of the result is not guaranteed to be correct * if the magnitude of the product is not representable. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64Multiply( SInt64 left, SInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64Multiply(SInt64 left, SInt64 right) { return (SInt64)(left) * (SInt64)(right); } #else #define S64Multiply(left, right) ((SInt64)(left) * (SInt64)(right)) #endif #endif /* * S64Mod() * * Discussion: * Returns the remainder of divide of dividend by divisor. The sign * of the remainder is the same as the sign of the dividend (i.e., * it takes the absolute values of the operands, does the division, * then fixes the sign of the quotient and remainder). * * Availability: * Implemented by client */ EXTERN_API_C( SInt64 ) S64Mod( SInt64 dividend, SInt64 divisor); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64Mod(SInt64 dividend, SInt64 divisor) { return (SInt64)(dividend) % (SInt64)(divisor); } #else #define S64Mod(dividend, divisor) ((SInt64)(dividend) % (SInt64)(divisor)) #endif #endif /* * S64Divide() * * Discussion: * Divides dividend by divisor, returning the quotient. The * remainder is returned in *remainder if remainder (the pointer) is * non-NULL. The sign of the remainder is the same as the sign of * the dividend (i.e. it takes the absolute values of the operands, * does the division, then fixes the sign of the quotient and * remainder). If the divisor is zero, then S64Max() will be * returned (or S64Min() if the dividend is negative), and the * remainder will be the dividend; no error is reported. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64Divide( SInt64 dividend, SInt64 divisor, SInt64 * remainder); /* can be NULL */ #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64Divide(SInt64 dividend, SInt64 divisor, SInt64 *remainder) { return ( (void)((remainder) && (*((SInt64*)(remainder)) = ((SInt64)(dividend) % (SInt64)(divisor)))), ((SInt64)(dividend) / (SInt64)(divisor)) ); } #else #define S64Divide(dividend, divisor, remainder) (( (void)((remainder) && (*((SInt64*)(remainder)) = ((SInt64)(dividend) % (SInt64)(divisor)))), ((SInt64)(dividend) / (SInt64)(divisor)) )) #endif #endif /* * S64Div() * * Discussion: * Divides dividend by divisor, returning the quotient. * * Availability: * Implemented by client */ EXTERN_API_C( SInt64 ) S64Div( SInt64 dividend, SInt64 divisor); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64Div(SInt64 dividend, SInt64 divisor) { return S64Divide((dividend), (divisor), NULL); } #else #define S64Div(dividend, divisor) (S64Divide((dividend), (divisor), NULL)) #endif #endif /* * S64Set() * * Discussion: * Given an SInt32, returns an SInt64 with the same value. Use this * routine instead of coding 64-bit constants (at least when the * constant will fit in an SInt32). * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64Set(SInt32 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64Set(SInt32 value) { return (SInt64)(value); } #else #define S64Set(value) ((SInt64)(value)) #endif #endif /* * S64SetU() * * Discussion: * Given a UInt32, returns a SInt64 with the same value. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64SetU(UInt32 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64SetU(UInt32 value) { return (SInt64)(value); } #else #define S64SetU(value) ((SInt64)(value)) #endif #endif /* * S32Set() * * Discussion: * Given an SInt64, returns an SInt32 by discarding the high-order * 32 bits. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt32 ) S32Set(SInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt32 ) S32Set(SInt64 value) { return (SInt32)(value); } #else #define S32Set(value) ((SInt32)(value)) #endif #endif /* * S64And() * * Discussion: * Returns one if left and right are non-zero, otherwise returns zero * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( Boolean ) S64And( SInt64 left, SInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(Boolean ) S64And(SInt64 left, SInt64 right) { return (SInt64)(left) && (SInt64)(right); } #else #define S64And(left, right) ((SInt64)(left) && (SInt64)(right)) #endif #endif /* * S64Or() * * Discussion: * Returns one if left or right are non-zero, otherwise returns zero * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( Boolean ) S64Or( SInt64 left, SInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(Boolean ) S64Or(SInt64 left, SInt64 right) { return (SInt64)(left) || (SInt64)(right); } #else #define S64Or(left, right) ((SInt64)(left) || (SInt64)(right)) #endif #endif /* * S64Eor() * * Discussion: * Returns one if left xor right are non-zero, otherwise returns zero * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( Boolean ) S64Eor( SInt64 left, SInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(Boolean ) S64Eor(SInt64 left, SInt64 right) { return (Boolean)(((SInt64)(left) ? 1 : 0) ^ ((SInt64)(right) ? 1 : 0)); } #else #define S64Eor(left, right) ((Boolean)(((SInt64)(left) ? 1 : 0) ^ ((SInt64)(right) ? 1 : 0))) #endif #endif /* * S64Not() * * Discussion: * Returns one if value is non-zero, otherwisze returns zero. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( Boolean ) S64Not(SInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(Boolean ) S64Not(SInt64 value) { return !((SInt64)(value)); } #else #define S64Not(value) (!((SInt64)(value))) #endif #endif /* * S64Compare() * * Discussion: * Given two signed numbers, left and right, returns an SInt32 that * compares with zero the same way left compares with right. If you * wanted to perform a comparison on 64-bit integers of the * form: * operand_1 operand_2 * then you could use an expression of the form: * xxxS64Compare(operand_1,operand_2) 0 * to test for the same condition. CAUTION: DO NOT depend on the * exact value returned by this routine. Only the sign (i.e. * positive, zero, or negative) of the result is guaranteed. * * Availability: * Non-Carbon CFM: not available * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt32 ) S64Compare( SInt64 left, SInt64 right); /* * S64BitwiseAnd() * * Discussion: * bitwise AND * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64BitwiseAnd( SInt64 left, SInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64BitwiseAnd(SInt64 left, SInt64 right) { return (SInt64)(left) & (SInt64)(right); } #else #define S64BitwiseAnd(left, right) ((SInt64)(left) & (SInt64)(right)) #endif #endif /* * S64BitwiseOr() * * Discussion: * bitwise OR * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64BitwiseOr( SInt64 left, SInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64BitwiseOr(SInt64 left, SInt64 right) { return (SInt64)(left) | (SInt64)(right); } #else #define S64BitwiseOr(left, right) ((SInt64)(left) | (SInt64)(right)) #endif #endif /* * S64BitwiseEor() * * Discussion: * bitwise XOR * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64BitwiseEor( SInt64 left, SInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64BitwiseEor(SInt64 left, SInt64 right) { return (SInt64)(left) ^ (SInt64)(right); } #else #define S64BitwiseEor(left, right) ((SInt64)(left) ^ (SInt64)(right)) #endif #endif /* * S64BitwiseNot() * * Discussion: * bitwise negate * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64BitwiseNot(SInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64BitwiseNot(SInt64 value) { return ~((SInt64)(value)); } #else #define S64BitwiseNot(value) (~((SInt64)(value))) #endif #endif /* * S64ShiftRight() * * Discussion: * Arithmetic shift of value by the lower 7 bits of the shift. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64ShiftRight( SInt64 value, UInt32 shift); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64ShiftRight(SInt64 value, UInt32 shift) { return (SInt64)(value) >> ((shift) & 0x7F); } #else #define S64ShiftRight(value, shift) ((SInt64)(value) >> ((shift) & 0x7F)) #endif #endif /* * S64ShiftLeft() * * Discussion: * Logical shift of value by the lower 7 bits of the shift. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) S64ShiftLeft( SInt64 value, UInt32 shift); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) S64ShiftLeft(SInt64 value, UInt32 shift) { return (SInt64)(value) << ((shift) & 0x7F); } #else #define S64ShiftLeft(value, shift) ((SInt64)(value) << ((shift) & 0x7F)) #endif #endif #if !TYPE_LONGDOUBLE_IS_DOUBLE /* * SInt64ToLongDouble() * * Discussion: * Converts SInt64 to long double. Note all SInt64s fit exactly * into long doubles, thus, the binary -> decimal conversion * routines in fp.h can be used to achieve SInt64 -> long double -> * decimal conversions. Note: The function implementation assumes * long double is a 128-bit floating point on PowerPC and 80-bit * type on 68K * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) SInt64ToLongDouble(SInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(long double ) SInt64ToLongDouble(SInt64 value) { return (long double)(value); } #else #define SInt64ToLongDouble(value) ((long double)(value)) #endif #endif /* * LongDoubleToSInt64() * * Discussion: * Converts a long double to a SInt64. Any decimal string that fits * into a SInt64 can be converted exactly into a long double, using * the conversion routines found in fp.h. Then this routine can be * used to complete the conversion to SInt64. Note: The function * implementation assumes long double is a 128-bit floating point on * PowerPC and 80-bit type on 68K * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( SInt64 ) LongDoubleToSInt64(long double value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) LongDoubleToSInt64(long double value) { return (SInt64)(value); } #else #define LongDoubleToSInt64(value) ((SInt64)(value)) #endif #endif #endif /* !TYPE_LONGDOUBLE_IS_DOUBLE */ #if TYPE_LONGLONG && TARGET_OS_WIN32 #define U64Max() 0xffffffffffffffffui64 #elif TYPE_LONGLONG && defined(__MWERKS__) && (__MWERKS__ < 0x1800) #define U64Max() 0xffffffffffffffff #else /* * U64Max() * * Discussion: * Returns largest possible UInt64 value * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64Max(void); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64Max(void) { return 0xffffffffffffffffULL; } #else #define U64Max() (0xffffffffffffffffULL) #endif #endif #endif /* * U64Add() * * Discussion: * Adds two unsigned integers, producing an integer result. If an * overflow occurs the result is congruent mod (2^64) as if the * operands and result were unsigned. No overflow is signaled. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64Add( UInt64 left, UInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64Add(UInt64 left, UInt64 right) { return (UInt64)(left) + (UInt64)(right); } #else #define U64Add(left, right) ((UInt64)(left) + (UInt64)(right)) #endif #endif /* * U64Subtract() * * Discussion: * Subtracts two unsigned integers, producing an integer result. If * an overflow occurs the result is congruent mod (2^64) as if the * operands and result were unsigned. No overflow is signaled. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64Subtract( UInt64 left, UInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64Subtract(UInt64 left, UInt64 right) { return (UInt64)(left) - (UInt64)(right); } #else #define U64Subtract(left, right) ((UInt64)(left) - (UInt64)(right)) #endif #endif /* * U64Multiply() * * Discussion: * Multiplies two unsigned numbers, producing a signed result. * Overflow is ignored and the low-order part of the product is * returned. The sign of the result is not guaranteed to be correct * if the magnitude of the product is not representable. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64Multiply( UInt64 left, UInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64Multiply(UInt64 left, UInt64 right) { return (UInt64)(left) * (UInt64)(right); } #else #define U64Multiply(left, right) ((UInt64)(left) * (UInt64)(right)) #endif #endif /* * U64Mod() * * Discussion: * Returns the remainder of divide of dividend by divisor. The sign * of the remainder is the same as the sign of the dividend (i.e., * it takes the absolute values of the operands, does the division, * then fixes the sign of the quotient and remainder). * * Availability: * Implemented by client */ EXTERN_API_C( UInt64 ) U64Mod( UInt64 dividend, UInt64 divisor); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64Mod(UInt64 dividend, UInt64 divisor) { return (UInt64)(dividend) % (UInt64)(divisor); } #else #define U64Mod(dividend, divisor) ((UInt64)(dividend) % (UInt64)(divisor)) #endif #endif /* * U64Divide() * * Discussion: * Divides dividend by divisor, returning the quotient. The * remainder is returned in *remainder if remainder (the pointer) is * non-NULL. The sign of the remainder is the same as the sign of * the dividend (i.e. it takes the absolute values of the operands, * does the division, then fixes the sign of the quotient and * remainder). If the divisor is zero, then U64Max() will be * returned (or U64Min() if the dividend is negative), and the * remainder will be the dividend; no error is reported. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64Divide( UInt64 dividend, UInt64 divisor, UInt64 * remainder); /* can be NULL */ #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64Divide(UInt64 dividend, UInt64 divisor, UInt64 *remainder) { return ( (void)((remainder) && (*((UInt64*)(remainder)) = ((UInt64)(dividend) % (UInt64)(divisor)))), ((UInt64)(dividend) / (UInt64)(divisor)) ); } #else #define U64Divide(dividend, divisor, remainder) (( (void)((remainder) && (*((UInt64*)(remainder)) = ((UInt64)(dividend) % (UInt64)(divisor)))), ((UInt64)(dividend) / (UInt64)(divisor)) )) #endif #endif /* * U64Div() * * Discussion: * Divides dividend by divisor, returning the quotient. * * Availability: * Implemented by client */ EXTERN_API_C( UInt64 ) U64Div( UInt64 dividend, UInt64 divisor); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64Div(UInt64 dividend, UInt64 divisor) { return U64Divide((dividend), (divisor), NULL); } #else #define U64Div(dividend, divisor) (U64Divide((dividend), (divisor), NULL)) #endif #endif /* * U64Set() * * Discussion: * Given an SInt32, returns an UInt64 with the same value. Use this * routine instead of coding 64-bit constants (at least when the * constant will fit in an SInt32). * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64Set(SInt32 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64Set(SInt32 value) { return (UInt64)(value); } #else #define U64Set(value) ((UInt64)(value)) #endif #endif /* * U64SetU() * * Discussion: * Given a UInt32, returns a UInt64 with the same value. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64SetU(UInt32 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64SetU(UInt32 value) { return (UInt64)(value); } #else #define U64SetU(value) ((UInt64)(value)) #endif #endif /* * U32SetU() * * Discussion: * Given an UInt64, returns an UInt32 by discarding the high-order * 32 bits. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt32 ) U32SetU(UInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt32 ) U32SetU(UInt64 value) { return (UInt32)(value); } #else #define U32SetU(value) ((UInt32)(value)) #endif #endif /* * U64And() * * Discussion: * Returns one if left and right are non-zero, otherwise returns zero * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( Boolean ) U64And( UInt64 left, UInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(Boolean ) U64And(UInt64 left, UInt64 right) { return (UInt64)(left) && (UInt64)(right); } #else #define U64And(left, right) ((UInt64)(left) && (UInt64)(right)) #endif #endif /* * U64Or() * * Discussion: * Returns one if left or right are non-zero, otherwise returns zero * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( Boolean ) U64Or( UInt64 left, UInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(Boolean ) U64Or(UInt64 left, UInt64 right) { return (UInt64)(left) || (UInt64)(right); } #else #define U64Or(left, right) ((UInt64)(left) || (UInt64)(right)) #endif #endif /* * U64Eor() * * Discussion: * Returns one if left xor right are non-zero, otherwise returns zero * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( Boolean ) U64Eor( UInt64 left, UInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(Boolean ) U64Eor(UInt64 left, UInt64 right) { return (Boolean)(((UInt64)(left) ? 1 : 0) ^ ((UInt64)(right) ? 1 : 0)); } #else #define U64Eor(left, right) ((Boolean)(((UInt64)(left) ? 1 : 0) ^ ((UInt64)(right) ? 1 : 0))) #endif #endif /* * U64Not() * * Discussion: * Returns one if value is non-zero, otherwisze returns zero. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( Boolean ) U64Not(UInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(Boolean ) U64Not(UInt64 value) { return !((UInt64)(value)); } #else #define U64Not(value) (!((UInt64)(value))) #endif #endif /* * U64Compare() * * Discussion: * Given two unsigned numbers, left and right, returns an SInt32 * that compares with zero the same way left compares with right. * If you wanted to perform a comparison on 64-bit integers of the * form: * operand_1 operand_2 * then you could use an expression of the form: * xxxU64Compare(operand_1,operand_2) 0 * to test for the same condition. CAUTION: DO NOT depend on the * exact value returned by this routine. Only the sign (i.e. * positive, zero, or negative) of the result is guaranteed. * * Availability: * Non-Carbon CFM: not available * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt32 ) U64Compare( UInt64 left, UInt64 right); /* * U64BitwiseAnd() * * Discussion: * bitwise AND * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64BitwiseAnd( UInt64 left, UInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64BitwiseAnd(UInt64 left, UInt64 right) { return (UInt64)(left) & (UInt64)(right); } #else #define U64BitwiseAnd(left, right) ((UInt64)(left) & (UInt64)(right)) #endif #endif /* * U64BitwiseOr() * * Discussion: * bitwise OR * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64BitwiseOr( UInt64 left, UInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64BitwiseOr(UInt64 left, UInt64 right) { return (UInt64)(left) | (UInt64)(right); } #else #define U64BitwiseOr(left, right) ((UInt64)(left) | (UInt64)(right)) #endif #endif /* * U64BitwiseEor() * * Discussion: * bitwise XOR * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64BitwiseEor( UInt64 left, UInt64 right); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64BitwiseEor(UInt64 left, UInt64 right) { return (UInt64)(left) ^ (UInt64)(right); } #else #define U64BitwiseEor(left, right) ((UInt64)(left) ^ (UInt64)(right)) #endif #endif /* * U64BitwiseNot() * * Discussion: * bitwise negate * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64BitwiseNot(UInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64BitwiseNot(UInt64 value) { return ~((UInt64)(value)); } #else #define U64BitwiseNot(value) (~((UInt64)(value))) #endif #endif /* * U64ShiftRight() * * Discussion: * Arithmetic shift of value by the lower 7 bits of the shift. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64ShiftRight( UInt64 value, UInt32 shift); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64ShiftRight(UInt64 value, UInt32 shift) { return (UInt64)(value) >> ((shift) & 0x7F); } #else #define U64ShiftRight(value, shift) ((UInt64)(value) >> ((shift) & 0x7F)) #endif #endif /* * U64ShiftLeft() * * Discussion: * Logical shift of value by the lower 7 bits of the shift. * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) U64ShiftLeft( UInt64 value, UInt32 shift); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) U64ShiftLeft(UInt64 value, UInt32 shift) { return (UInt64)(value) << ((shift) & 0x7F); } #else #define U64ShiftLeft(value, shift) ((UInt64)(value) << ((shift) & 0x7F)) #endif #endif #if !TYPE_LONGDOUBLE_IS_DOUBLE /* * UInt64ToLongDouble() * * Discussion: * Convert an signed 64 bit integer to a long double (128-bit on * PowerPC floating point) * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) UInt64ToLongDouble(UInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(long double ) UInt64ToLongDouble(UInt64 value) { return (long double)(value); } #else #define UInt64ToLongDouble(value) ((long double)(value)) #endif #endif /* * LongDoubleToUInt64() * * Discussion: * Convert long double (128-bit on PowerPC floating point) to a * signed 64-bit integer * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( UInt64 ) LongDoubleToUInt64(long double value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) LongDoubleToUInt64(long double value) { return (UInt64)(value); } #else #define LongDoubleToUInt64(value) ((UInt64)(value)) #endif #endif #endif /* !TYPE_LONGDOUBLE_IS_DOUBLE */ /* * UInt64ToSInt64() * * Discussion: * converts UInt64 -> SInt64 * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( SInt64 ) UInt64ToSInt64(UInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(SInt64 ) UInt64ToSInt64(UInt64 value) { return (SInt64)(value); } #else #define UInt64ToSInt64(value) ((SInt64)(value)) #endif #endif /* * SInt64ToUInt64() * * Discussion: * converts SInt64 -> UInt64 * * Availability: * Non-Carbon CFM: available as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( UInt64 ) SInt64ToUInt64(SInt64 value); #if TYPE_LONGLONG #ifdef __cplusplus inline DEFINE_API_C(UInt64 ) SInt64ToUInt64(SInt64 value) { return (UInt64)(value); } #else #define SInt64ToUInt64(value) ((UInt64)(value)) #endif #endif /* Functions to convert between [Unsigned]Wide and [S|U]Int64 types. These functions are necessary if source code which uses both wide and SInt64 is to compile under a compiler that supports long long. SInt64ToWide Converts a SInt64 to a wide struct. If SInt64 is implemented as a typedef of wide, the macro does nothing. If SInt64 is implemented as a long long, it casts the long long into a wide struct. WideToSInt64 Converts a wide struct into a SInt64. If SInt64 is implemented as a typedef of wide, the macro does nothing. If SInt64 is implemented as a long long, it reads the struct into a long long. */ #if TYPE_LONGLONG #define SInt64ToWide(x) (*((wide*)(&(x)))) #define WideToSInt64(x) (*((SInt64*)(&(x)))) #define UInt64ToUnsignedWide(x) (*((UnsignedWide*)(&(x)))) #define UnsignedWideToUInt64(x) (*((UInt64*)(&(x)))) #else #define SInt64ToWide(x) (x) #define WideToSInt64(x) (x) #define UInt64ToUnsignedWide(x) (x) #define UnsignedWideToUInt64(x) (x) #endif #ifdef PRAGMA_IMPORT_OFF #pragma import off #elif PRAGMA_IMPORT #pragma import reset #endif #ifdef __cplusplus } #endif #endif /* __MATH64__ */