Return to divlarge.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / largeint / i386

Annotation of mstools/samples/largeint/i386/divlarge.c, revision 1.1

1.1     ! root        1: /*++
        !             2: 
        !             3: Module Name:
        !             4: 
        !             5:     divlarge.c
        !             6: 
        !             7: Abstract:
        !             8: 
        !             9:     This module implements the runtime library large integer divide
        !            10:     routines.
        !            11: 
        !            12:     N.B. These routines use a one bit at a time algorithm and is slow.
        !            13:          They should be used only when absolutely necessary.
        !            14: 
        !            15: Revision History:
        !            16: 
        !            17: --*/
        !            18: 
        !            19: #include "windows.h"
        !            20: #include "divlarge.h"
        !            21: 
        !            22: LARGE_INTEGER
        !            23: WINAPI
        !            24: LargeIntegerDivide (
        !            25:     IN LARGE_INTEGER Dividend,
        !            26:     IN LARGE_INTEGER Divisor,
        !            27:     OUT PLARGE_INTEGER Remainder OPTIONAL
        !            28:     )
        !            29: 
        !            30: /*++
        !            31: 
        !            32: Routine Description:
        !            33: 
        !            34:     This routine divides an unsigned 64-bit dividend by an unsigned 64-bit
        !            35:     divisor and returns a 64-bit quotient, and optionally a 64-bit remainder.
        !            36: 
        !            37: Arguments:
        !            38: 
        !            39:     Dividend - Supplies the 64-bit dividend for the divide operation.
        !            40: 
        !            41:     Divisor - Supplies the 64-bit divisor for the divide operation.
        !            42: 
        !            43:     Remainder - Supplies an optional pointer to a variable which receives
        !            44:         the remainder
        !            45: 
        !            46: Return Value:
        !            47: 
        !            48:     The 64-bit quotient is returned as the function value.
        !            49: 
        !            50: --*/
        !            51: 
        !            52: {
        !            53: 
        !            54:     ULONG Index = 64;
        !            55:     LARGE_INTEGER Partial = {0, 0};
        !            56:     LARGE_INTEGER Quotient;
        !            57: 
        !            58:     //
        !            59:     // Loop through the dividend bits and compute the quotient and remainder.
        !            60:     //
        !            61: 
        !            62:     Quotient = Dividend;
        !            63:     do {
        !            64: 
        !            65:         //
        !            66:         // Shift the next dividend bit into the parital remainder and shift
        !            67:         // the partial quotient (dividend) left one bit.
        !            68:         //
        !            69: 
        !            70:         Partial.HighPart = (Partial.HighPart << 1) | (Partial.LowPart >> 31);
        !            71:         Partial.LowPart = (Partial.LowPart << 1) | ((ULONG)Quotient.HighPart >> 31);
        !            72:         Quotient.HighPart = (Quotient.HighPart << 1) | (Quotient.LowPart >> 31);
        !            73:         Quotient.LowPart <<= 1;
        !            74: 
        !            75:         //
        !            76:         // If the partial remainder is greater than or equal to the divisor,
        !            77:         // then subtract the divisor from the partial remainder and insert a
        !            78:         // one bit into the quotient.
        !            79:         //
        !            80: 
        !            81:         if (((ULONG)Partial.HighPart > (ULONG)Divisor.HighPart) ||
        !            82:             ((Partial.HighPart == Divisor.HighPart) &&
        !            83:             (Partial.LowPart >= Divisor.LowPart))) {
        !            84: 
        !            85:             Quotient.LowPart |= 1;
        !            86:             Partial.HighPart -= Divisor.HighPart;
        !            87:             if (Partial.LowPart < Divisor.LowPart) {
        !            88:                 Partial.HighPart -= 1;
        !            89:             }
        !            90: 
        !            91:             Partial.LowPart -= Divisor.LowPart;
        !            92:         }
        !            93: 
        !            94:         Index -= 1;
        !            95:     } while (Index > 0);
        !            96: 
        !            97:     //
        !            98:     // If the remainder is requested, then return the 64-bit remainder.
        !            99:     //
        !           100: 
        !           101:     if (ARGUMENT_PRESENT(Remainder)) {
        !           102:         *Remainder = Partial;
        !           103:     }
        !           104: 
        !           105:     //
        !           106:     // Return the 64-bit quotient.
        !           107:     //
        !           108: 
        !           109:     return Quotient;
        !           110: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.