Create a branch for header work.

svn path=/branches/header-work/; revision=45691
2025-06-20 07:36:05 +00:00 · 2010-02-26 22:57:55 +00:00 · 2010-02-26 22:57:55 +00:00 · 9ea495ba33
commit 9ea495ba33
parent 14fe274b1c
19538 changed files with 0 additions and 1063950 deletions
--- a/lib/rtl/largeint.c
+++ b/lib/rtl/largeint.c
@ -0,0 +1,351 @@
+/* COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS system libraries
+ * FILE:            lib/rtl/largeint.c
+ * PURPOSE:         Large integer operations
+ * PROGRAMMERS:
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <rtl.h>
+
+#define NDEBUG
+#include <debug.h>
+
+/* FUNCTIONS *****************************************************************/
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlConvertLongToLargeInteger (
+   LONG SignedInteger
+)
+{
+   LARGE_INTEGER RC;
+
+   RC.QuadPart = SignedInteger;
+
+   return RC;
+}
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlConvertUlongToLargeInteger (
+   ULONG UnsignedInteger
+)
+{
+   LARGE_INTEGER RC;
+
+   RC.QuadPart = UnsignedInteger;
+
+   return RC;
+}
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlEnlargedIntegerMultiply (
+   LONG Multiplicand,
+   LONG Multiplier
+)
+{
+   LARGE_INTEGER RC;
+
+   RC.QuadPart = (LONGLONG) Multiplicand * Multiplier;
+
+   return RC;
+}
+
+/*
+ * @implemented
+ */
+ULONG
+NTAPI
+RtlEnlargedUnsignedDivide (
+   ULARGE_INTEGER Dividend,
+   ULONG  Divisor,
+   PULONG  Remainder
+)
+{
+   if (Remainder)
+      *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
+
+   return (ULONG)(Dividend.QuadPart / Divisor);
+}
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlEnlargedUnsignedMultiply (
+   ULONG Multiplicand,
+   ULONG Multiplier
+)
+{
+   LARGE_INTEGER RC;
+
+   RC.QuadPart = (ULONGLONG) Multiplicand * Multiplier;
+
+   return RC;
+}
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlExtendedIntegerMultiply (
+   LARGE_INTEGER Multiplicand,
+   LONG  Multiplier
+)
+{
+   LARGE_INTEGER RC;
+
+   RC.QuadPart = Multiplicand.QuadPart * Multiplier;
+
+   return RC;
+}
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlExtendedLargeIntegerDivide (
+   LARGE_INTEGER Dividend,
+   ULONG  Divisor,
+   PULONG  Remainder
+)
+{
+   LARGE_INTEGER RC;
+
+   if (Remainder)
+      *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
+
+   RC.QuadPart = Dividend.QuadPart / Divisor;
+
+   return RC;
+}
+
+
+/******************************************************************************
+ * RtlExtendedMagicDivide
+ *
+ * Allows replacing a division by a longlong constant with a multiplication by
+ * the inverse constant.
+ *
+ * RETURNS
+ *  (Dividend * MagicDivisor) >> (64 + ShiftCount)
+ *
+ * NOTES
+ *  If the divisor of a division is constant, the constants MagicDivisor and
+ *  shift must be chosen such that
+ *  MagicDivisor = 2^(64 + ShiftCount) / Divisor.
+ *
+ *  Then we have RtlExtendedMagicDivide(Dividend,MagicDivisor,ShiftCount) ==
+ *  Dividend * MagicDivisor / 2^(64 + ShiftCount) == Dividend / Divisor.
+ *
+ *  The Parameter MagicDivisor although defined as LONGLONG is used as
+ *  ULONGLONG.
+ */
+
+#define LOWER_32(A) ((A) & 0xffffffff)
+#define UPPER_32(A) ((A) >> 32)
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER NTAPI
+RtlExtendedMagicDivide (LARGE_INTEGER Dividend,
+                        LARGE_INTEGER MagicDivisor,
+                        CCHAR ShiftCount)
+{
+   ULONGLONG dividend_high;
+   ULONGLONG dividend_low;
+   ULONGLONG inverse_divisor_high;
+   ULONGLONG inverse_divisor_low;
+   ULONGLONG ah_bl;
+   ULONGLONG al_bh;
+   LARGE_INTEGER result;
+   BOOLEAN positive;
+
+   if (Dividend.QuadPart < 0)
+   {
+      dividend_high = UPPER_32((ULONGLONG) -Dividend.QuadPart);
+      dividend_low =  LOWER_32((ULONGLONG) -Dividend.QuadPart);
+      positive = FALSE;
+   }
+   else
+   {
+      dividend_high = UPPER_32((ULONGLONG) Dividend.QuadPart);
+      dividend_low =  LOWER_32((ULONGLONG) Dividend.QuadPart);
+      positive = TRUE;
+   }
+   inverse_divisor_high = UPPER_32((ULONGLONG) MagicDivisor.QuadPart);
+   inverse_divisor_low =  LOWER_32((ULONGLONG) MagicDivisor.QuadPart);
+
+   ah_bl = dividend_high * inverse_divisor_low;
+   al_bh = dividend_low * inverse_divisor_high;
+
+   result.QuadPart =
+      (LONGLONG) ((dividend_high * inverse_divisor_high +
+                   UPPER_32(ah_bl) +
+                   UPPER_32(al_bh) +
+                   UPPER_32(LOWER_32(ah_bl) + LOWER_32(al_bh) +
+                            UPPER_32(dividend_low * inverse_divisor_low))) >> ShiftCount);
+   if (!positive)
+   {
+      result.QuadPart = -result.QuadPart;
+   }
+
+   return result;
+}
+
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlLargeIntegerAdd (
+   LARGE_INTEGER Addend1,
+   LARGE_INTEGER Addend2
+)
+{
+   LARGE_INTEGER RC;
+
+   RC.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
+
+   return RC;
+}
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlLargeIntegerArithmeticShift (
+   LARGE_INTEGER LargeInteger,
+   CCHAR  ShiftCount
+)
+{
+   LARGE_INTEGER RC;
+   CHAR Shift;
+
+   Shift = ShiftCount % 64;
+
+   if (Shift < 32)
+   {
+      RC.QuadPart = LargeInteger.QuadPart >> Shift;
+   }
+   else
+   {
+      /* copy the sign bit */
+      RC.u.HighPart = (LargeInteger.u.HighPart & 0x80000000);
+      RC.u.LowPart = LargeInteger.u.HighPart >> Shift;
+   }
+
+   return RC;
+}
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlLargeIntegerDivide (
+   LARGE_INTEGER Dividend,
+   LARGE_INTEGER Divisor,
+   PLARGE_INTEGER Remainder
+)
+{
+   LARGE_INTEGER RC;
+
+   if (Remainder)
+      Remainder->QuadPart = Dividend.QuadPart % Divisor.QuadPart;
+
+   RC.QuadPart = Dividend.QuadPart / Divisor.QuadPart;
+
+   return RC;
+}
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlLargeIntegerNegate (
+   LARGE_INTEGER Subtrahend
+)
+{
+   LARGE_INTEGER RC;
+
+   RC.QuadPart = - Subtrahend.QuadPart;
+
+   return RC;
+}
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlLargeIntegerShiftLeft (
+   LARGE_INTEGER LargeInteger,
+   CCHAR  ShiftCount
+)
+{
+   LARGE_INTEGER RC;
+   CCHAR Shift;
+
+   Shift = ShiftCount % 64;
+   RC.QuadPart = LargeInteger.QuadPart << Shift;
+
+   return RC;
+}
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlLargeIntegerShiftRight (
+   LARGE_INTEGER LargeInteger,
+   CCHAR  ShiftCount
+)
+{
+   LARGE_INTEGER RC;
+   CCHAR Shift;
+
+   Shift = ShiftCount % 64;
+   RC.QuadPart = LargeInteger.QuadPart >> Shift;
+
+   return RC;
+}
+
+/*
+ * @implemented
+ */
+LARGE_INTEGER
+NTAPI
+RtlLargeIntegerSubtract (
+   LARGE_INTEGER Minuend,
+   LARGE_INTEGER Subtrahend
+)
+{
+   LARGE_INTEGER RC;
+
+   RC.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
+
+   return RC;
+}
+
+/* EOF */