archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
3.8 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/base/efiutil/efilib/inc/bigint.hxx

1280 lines
18 KiB
Raw Blame History

/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
bigint.hxx
Abstract:
The BIG_INT class models a 64 bit signed integer.
This class is meant to be light and will occupy only 64 bits of space.
It should be manipulated exactly as an INT would be.
There will be no constructor or destructor. A BIG_INT will be
uninitialized until a value is assigned to it.
This implementation of BIG_INT uses the NT LARGE_INTEGER structure.
--*/
#if !defined(BIG_INT_DEFN)
#define BIG_INT_DEFN
#include <ulib.hxx>
#if defined ( _AUTOCHECK_ ) || defined( _EFICHECK_ )
#define IFSUTIL_EXPORT
#elif defined ( _IFSUTIL_MEMBER_ )
#define IFSUTIL_EXPORT __declspec(dllexport)
#else
#define IFSUTIL_EXPORT __declspec(dllimport)
#endif
DEFINE_POINTER_AND_REFERENCE_TYPES( LARGE_INTEGER );
DECLARE_CLASS( BIG_INT );
class BIG_INT {
public:
NONVIRTUAL
BIG_INT(
);
NONVIRTUAL
BIG_INT(
IN const INT LowPart
);
NONVIRTUAL
BIG_INT(
IN const UINT LowPart
);
NONVIRTUAL
BIG_INT(
IN const ULONG LowPart
);
NONVIRTUAL
BIG_INT(
IN const SLONG LowPart
);
NONVIRTUAL
BIG_INT(
IN const LARGE_INTEGER LargeInteger
);
NONVIRTUAL
BIG_INT(
IN const ULONGLONG UlongLong
);
NONVIRTUAL
VOID
operator=(
IN const INT LowPart
);
NONVIRTUAL
VOID
operator=(
IN const UINT LowPart
);
NONVIRTUAL
VOID
operator=(
IN const SLONG LowPart
);
NONVIRTUAL
VOID
operator=(
IN const ULONG LowPart
);
NONVIRTUAL
VOID
operator=(
IN const LARGE_INTEGER LargeInteger
);
NONVIRTUAL
VOID
operator=(
IN const LONG64 Long64
)
{
x = Long64;
}
NONVIRTUAL
VOID
operator=(
IN const ULONG64 Ulong64
)
{
x = Ulong64;
}
NONVIRTUAL
VOID
Set(
IN const ULONG LowPart,
IN const SLONG HighPart
);
NONVIRTUAL
IFSUTIL_EXPORT
VOID
Set(
IN UCHAR ByteCount,
IN PCUCHAR CompressedInteger
);
NONVIRTUAL
const ULONG
GetLowPart(
) CONST;
NONVIRTUAL
const SLONG
GetHighPart(
) CONST;
NONVIRTUAL
LARGE_INTEGER
GetLargeInteger(
) CONST;
NONVIRTUAL
LONGLONG
GetQuadPart(
) CONST;
NONVIRTUAL
IFSUTIL_EXPORT
VOID
QueryCompressedInteger(
OUT PUCHAR ByteCount,
OUT PUCHAR CompressedInteger
) CONST;
NONVIRTUAL
VOID
operator+=(
IN const BIG_INT BigInt
);
NONVIRTUAL
BIG_INT
operator-(
) CONST;
NONVIRTUAL
VOID
operator-=(
IN const BIG_INT BigInt
);
FRIEND
BIG_INT
operator+(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BIG_INT
operator-(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BIG_INT
operator*(
IN const BIG_INT Left,
IN const SLONG Right
);
FRIEND
BIG_INT
operator*(
IN const SLONG Left,
IN const BIG_INT Right
);
FRIEND
BIG_INT
operator/(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BIG_INT
operator%(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BOOLEAN
operator==(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BOOLEAN
operator!=(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BOOLEAN
operator<(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BOOLEAN
operator<=(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BOOLEAN
operator>(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BOOLEAN
operator>=(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BOOLEAN
CompareLT(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BOOLEAN
CompareLTEQ(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BOOLEAN
CompareGT(
IN const BIG_INT Left,
IN const BIG_INT Right
);
FRIEND
BOOLEAN
CompareGTEQ(
IN const BIG_INT Left,
IN const BIG_INT Right
);
private:
__int64 x;
};
INLINE
BIG_INT::BIG_INT(
)
/*++
Routine Description:
Constructor for BIG_INT.
Arguments:
None.
Return Value:
None.
--*/
{
}
INLINE
VOID
BIG_INT::operator=(
IN const INT LowPart
)
/*++
Routine Description:
This routine copies an INT into a BIG_INT.
Arguments:
LowPart - Supplies an integer.
Return Value:
None.
--*/
{
x = LowPart;
}
INLINE
VOID
BIG_INT::operator=(
IN const UINT LowPart
)
/*++
Routine Description:
This routine copies a UINT into a BIG_INT.
Arguments:
LowPart - Supplies an unsigned integer.
Return Value:
None.
--*/
{
x = LowPart;
}
INLINE
VOID
BIG_INT::operator=(
IN const SLONG LowPart
)
/*++
Routine Description:
This routine copies a LONG into a BIG_INT.
Arguments:
LowPart - Supplies a long integer.
Return Value:
None.
--*/
{
x = LowPart;
}
INLINE
VOID
BIG_INT::operator=(
IN const ULONG LowPart
)
/*++
Routine Description:
This routine copies a ULONG into a BIG_INT.
Arguments:
LowPart - Supplies an unsigned long integer.
Return Value:
None.
--*/
{
x = LowPart;
}
INLINE
VOID
BIG_INT::operator=(
IN const LARGE_INTEGER LargeInteger
)
/*++
Routine Description:
This routine copies a LARGE_INTEGER into a BIG_INT.
Arguments:
LargeInteger -- supplies a large integer
Return Value:
None.
--*/
{
x = LargeInteger.QuadPart;
}
INLINE
BIG_INT::BIG_INT(
IN const INT LowPart
)
/*++
Routine Description:
Constructor for BIG_INT.
Arguments:
LowPart - Supplies an integer.
Return Value:
None.
--*/
{
x = LowPart;
}
INLINE
BIG_INT::BIG_INT(
IN const UINT LowPart
)
/*++
Routine Description:
Constructor for BIG_INT.
Arguments:
LowPart - Supplies an unsigned integer.
Return Value:
None.
--*/
{
x = LowPart;
}
INLINE
BIG_INT::BIG_INT(
IN const SLONG LowPart
)
/*++
Routine Description:
Constructor for BIG_INT.
Arguments:
LowPart - Supplies a long integer.
Return Value:
None.
--*/
{
x = LowPart;
}
INLINE
BIG_INT::BIG_INT(
IN const ULONG LowPart
)
/*++
Routine Description:
Constructor for BIG_INT.
Arguments:
LowPart - Supplies an unsigned long integer.
Return Value:
None.
--*/
{
x = LowPart;
}
INLINE
BIG_INT::BIG_INT(
IN const LARGE_INTEGER LargeInteger
)
/*++
Routine Description:
Constructor for BIG_INT to permit initialization with a LARGE_INTEGER
Arguments:
LargeInteger -- supplies a large integer.
Return Value:
None.
--*/
{
x = LargeInteger.QuadPart;
}
INLINE
BIG_INT::BIG_INT(
IN const ULONGLONG UlongLong
)
/*++
Routine Description:
Constructor for BIG_INT to permit initialization with a ULONGLOGN
Arguments:
UlongLong -- supplies a unsigned 64-bit int.
Return Value:
None.
--*/
{
x = UlongLong;
}
INLINE
VOID
BIG_INT::Set(
IN const ULONG LowPart,
IN const SLONG HighPart
)
/*++
Routine Description:
This routine sets a BIG_INT to an initial value.
Arguments:
LowPart - Supplies the low part of the BIG_INT.
HighPart - Supplies the high part of the BIG_INT.
Return Value:
None.
--*/
{
x = (__int64)(((ULONGLONG)HighPart << 32) | LowPart);
}
INLINE
const ULONG
BIG_INT::GetLowPart(
) CONST
/*++
Routine Description:
This routine computes the low part of the BIG_INT.
Arguments:
None.
Return Value:
The low part of the BIG_INT.
--*/
{
return (ULONG)(((ULONGLONG)x) & 0xFFFFFFFF);
}
// Note: this could probably return an RCLONG, for
// greater efficiency, but that generates warnings.
INLINE
const SLONG
BIG_INT::GetHighPart(
) CONST
/*++
Routine Description:
This routine computes the high part of the BIG_INT.
Arguments:
None.
Return Value:
The high part of the BIG_INT.
--*/
{
LARGE_INTEGER r;
r.QuadPart = x;
return r.HighPart;
}
INLINE
LARGE_INTEGER
BIG_INT::GetLargeInteger(
) CONST
/*++
Routine Description:
This routine returns the large integer embedded in the BIG_INT.
Arguments:
None.
Return Value:
The large-integer value of the BIG_INT.
--*/
{
LARGE_INTEGER r;
r.QuadPart = x;
return r;
}
INLINE
LONGLONG
BIG_INT::GetQuadPart(
) CONST
/*++
Routine Description:
This routine returns the large integer embedded in the BIG_INT.
Arguments:
None.
Return Value:
The large-integer value of the BIG_INT.
--*/
{
return x;
}
INLINE
VOID
BIG_INT::operator+=(
IN const BIG_INT BigInt
)
/*++
Routine Description:
This routine adds another BIG_INT to this one.
Arguments:
BigInt - Supplies the BIG_INT to add to the current BIG_INT.
Return Value:
None.
--*/
{
x += BigInt.x;
}
INLINE
BIG_INT
BIG_INT::operator-(
) CONST
/*++
Routine Description:
This routine computes the negation of the current BIG_INT.
Arguments:
None.
Return Value:
The negation of the current BIG_INT.
--*/
{
BIG_INT r;
r.x = -x;
return r;
}
INLINE
VOID
BIG_INT::operator-=(
IN const BIG_INT BigInt
)
/*++
Routine Description:
This routine subtracts a BIG_INT from this one.
Arguments:
BigInt - Supplies a BIG_INT to subtract from the current BIG_INT.
Return Value:
None.
--*/
{
x -= BigInt.x;
}
INLINE
BIG_INT
operator+(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine computes the sum of two BIG_INTs.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
The sum of Left and Right.
--*/
{
BIG_INT r;
r.x = Left.x + Right.x;
return r;
}
INLINE
BIG_INT
operator-(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine computes the difference of two BIG_INTs.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
The difference between Left and Right.
--*/
{
BIG_INT r;
r.x = Left.x - Right.x;
return r;
}
INLINE
BIG_INT
operator*(
IN const BIG_INT Left,
IN const SLONG Right
)
/*++
Routine Description:
This routine computes the product of a BIG_INT and a LONG.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
The product of Left and Right.
--*/
{
BIG_INT r;
r.x = Left.x * Right;
return r;
}
INLINE
BIG_INT
operator*(
IN const SLONG Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine computes the product of a BIG_INT and a LONG.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
The product of Left and Right.
--*/
{
return Right*Left;
}
INLINE
BIG_INT
operator/(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine computes the quotient of two BIG_INTs.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
The quotient of Left and Right.
--*/
{
BIG_INT r;
r.x = Left.x / Right.x;
return r;
}
INLINE
BIG_INT
operator%(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine computes the modulus of two BIG_INTs.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
The modulus of Left and Right.
--*/
{
BIG_INT r;
r.x = Left.x % Right.x;
return r;
}
INLINE
BOOLEAN
operator<(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine compares two BIG_INTs.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
FALSE - Left is not less than Right.
TRUE - Left is less than Right.
--*/
{
return Left.x < Right.x;
}
INLINE
BOOLEAN
operator<=(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine compares two BIG_INTs.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
FALSE - Left is not less than or equal to Right.
TRUE - Left is less than or equal to Right.
--*/
{
return Left.x <= Right.x;
}
INLINE
BOOLEAN
operator>(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine compares two BIG_INTs.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
FALSE - Left is not greater than Right.
TRUE - Left is greater than Right.
--*/
{
return Left.x > Right.x;
}
INLINE
BOOLEAN
operator>=(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine compares two BIG_INTs.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
FALSE - Left is not greater than or equal to Right.
TRUE - Left is greater than or equal to Right.
--*/
{
return Left.x >= Right.x;
}
INLINE
BOOLEAN
operator==(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine compares two BIG_INTs for equality.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
FALSE - Left is not equal to Right.
TRUE - Left is equal to Right.
--*/
{
return Left.x == Right.x;
}
INLINE
BOOLEAN
operator!=(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine compares two BIG_INTs for equality.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
FALSE - Left is equal to Right.
TRUE - Left is not equal to Right.
--*/
{
return Left.x != Right.x;
}
INLINE
BOOLEAN
CompareGTEQ(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine compares two BIG_INTs by treating them
as unsigned numbers.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
FALSE - Left is not greater than or equal to Right.
TRUE - Left is greater than or equal to Right.
--*/
{
return (unsigned __int64)Left.x >= (unsigned __int64)Right.x;
}
INLINE
BOOLEAN
CompareGT(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine compares two BIG_INTs by treating them
as unsigned numbers.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
FALSE - Left is not greater than Right.
TRUE - Left is greater than Right.
--*/
{
return (unsigned __int64)Left.x > (unsigned __int64)Right.x;
}
INLINE
BOOLEAN
CompareLTEQ(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine compares two BIG_INTs by treating them
as unsigned numbers.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
FALSE - Left is not less than or equal to Right.
TRUE - Left is less than or equal to Right.
--*/
{
return (unsigned __int64)Left.x <= (unsigned __int64)Right.x;
}
INLINE
BOOLEAN
CompareLT(
IN const BIG_INT Left,
IN const BIG_INT Right
)
/*++
Routine Description:
This routine compares two BIG_INTs by treating them
as unsigned numbers.
Arguments:
Left - Supplies the left argument.
Right - Supplies the right argument.
Return Value:
FALSE - Left is not less than Right.
TRUE - Left is less than Right.
--*/
{
return (unsigned __int64)Left.x < (unsigned __int64)Right.x;
}
#endif // BIG_INT_DEFN