windows-xp/Source/XPSP1/NT/shell/osshell/accesory/ratpak/basex.c

//-----------------------------------------------------------------------------
//  Package Title  ratpak                                                   
//  File           basex.c                                                    
//  Author         Timothy David Corrie Jr. ([email protected])            
//  Copyright      (C) 1995-97 Microsoft                                    
//  Date           03-14-97                                                 
//                                                                          
//                                                                          
//  Description                                                             
//                                                                          
//     Contains number routines for internal base computations, these assume   
//  internal base is a power of 2.                                          
//                                                                          
//-----------------------------------------------------------------------------

#if defined( DOS )
#include <dosstub.h>
#else
#include <windows.h>
#endif
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <stdlib.h>
#include <ratpak.h>


// WARNING: This assumes return of a 64 bit entity is in edx:eax
// This assumption SHOULD always be true on X86
#pragma warning( disable : 4035 )
DWORDLONG __inline Mul32x32( IN DWORD a, IN DWORD b )

{
#ifdef _X86_ 
    __asm {
    mov eax, b
        mul a
        }
#else
    return (DWORDLONG)a * b;
#endif
}
#pragma warning( default : 4035 )

// Yeah well when the F__KING COMPILER gets a clue I'll change this back to 
// an inline (as opposed to the compiler looking at fastcall putting the args
// in registers, oh and then a) not making this inline, and b) pushing the 
// values anyway!

#ifdef _X86_ 
    #define Shr32xbase(x) \
            __asm { mov eax,DWORD PTR [x] } \
            __asm { mov edx,DWORD PTR [x+4] } \
            __asm { shrd eax,edx,BASEXPWR } \
            __asm { shr edx,BASEXPWR } \
            __asm { mov DWORD PTR [x],eax } \
            __asm { mov DWORD PTR [x+4],edx }
#else
    #define Shr32xbase(x) (x >>= BASEXPWR);
#endif



void _mulnumx( PNUMBER *pa, PNUMBER b );

//----------------------------------------------------------------------------
//
//    FUNCTION: mulnumx
//
//    ARGUMENTS: pointer to a number and a second number, the
//               base is always BASEX.
//
//    RETURN: None, changes first pointer.
//
//    DESCRIPTION: Does the number equivalent of *pa *= b.
//    This is a stub which prevents multiplication by 1, this is a big speed
//    improvement.
//
//----------------------------------------------------------------------------

void __inline mulnumx( PNUMBER *pa, PNUMBER b )

{
    if ( b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0 )
        {
        // If b is not one we multiply
        if ( (*pa)->cdigit > 1 || (*pa)->mant[0] != 1 || (*pa)->exp != 0 )
            { 
            // pa and b are both nonone.
            _mulnumx( pa, b );
            }
        else
            {
            // if pa is one and b isn't just copy b. and adjust the sign.
            long sign = (*pa)->sign;
            DUPNUM(*pa,b);
            (*pa)->sign *= sign;
            }
        }
    else
        {
        // B is +/- 1, But we do have to set the sign.
        (*pa)->sign *= b->sign;
        }
}

//----------------------------------------------------------------------------
//
//    FUNCTION: _mulnumx
//
//    ARGUMENTS: pointer to a number and a second number, the
//               base is always BASEX.
//
//    RETURN: None, changes first pointer.
//
//    DESCRIPTION: Does the number equivalent of *pa *= b.
//    Assumes the base is BASEX of both numbers.  This algorithm is the
//    same one you learned in gradeschool, except the base isn't 10 it's
//    BASEX.
//
//----------------------------------------------------------------------------

void _mulnumx( PNUMBER *pa, PNUMBER b )

{
    PNUMBER c=NULL;         // c will contain the result.
    PNUMBER a=NULL;         // a is the dereferenced number pointer from *pa
    MANTTYPE *ptra;         // ptra is a pointer to the mantissa of a.
    MANTTYPE *ptrb;         // ptrb is a pointer to the mantissa of b.
    MANTTYPE *ptrc;         // ptrc is a pointer to the mantissa of c.
    MANTTYPE *ptrcoffset;   // ptrcoffset, is the anchor location of the next
                            // single digit multiply partial result.
    long iadigit=0;         // Index of digit being used in the first number.
    long ibdigit=0;         // Index of digit being used in the second number.
    MANTTYPE      da=0;     // da is the digit from the fist number.
    TWO_MANTTYPE  cy=0;     // cy is the carry resulting from the addition of
                            // a multiplied row into the result.
    TWO_MANTTYPE  mcy=0;    // mcy is the resultant from a single 
                            // multiply, AND the carry of that multiply.
    long  icdigit=0;        // Index of digit being calculated in final result.

    a=*pa;

    ibdigit = a->cdigit + b->cdigit - 1;
    createnum( c,  ibdigit + 1 );
    c->cdigit = ibdigit;
    c->sign = a->sign * b->sign;

    c->exp = a->exp + b->exp;
    ptra = MANT(a);
    ptrcoffset = MANT(c);

    for (  iadigit = a->cdigit; iadigit > 0; iadigit-- )
        {
        da =  *ptra++;
        ptrb = MANT(b);
        
        // Shift ptrc, and ptrcoffset, one for each digit 
        ptrc = ptrcoffset++;

        for ( ibdigit = b->cdigit; ibdigit > 0; ibdigit-- )
            {
            cy = 0;
            mcy = Mul32x32( da, *ptrb );
            if ( mcy )
                {
                icdigit = 0;
                if ( ibdigit == 1 && iadigit == 1 )
                    {
                    c->cdigit++;
                    }
                }
            // If result is nonzero, or while result of carry is nonzero...
            while ( mcy || cy )
                {
                
                // update carry from addition(s) and multiply.
                cy += (TWO_MANTTYPE)ptrc[icdigit]+((DWORD)mcy&((DWORD)~BASEX));
                
                // update result digit from 
                ptrc[icdigit++]=(MANTTYPE)((DWORD)cy&((DWORD)~BASEX));
                
                // update carries from
                Shr32xbase( mcy );
                Shr32xbase( cy );
                }
            *ptrb++;
            *ptrc++;
            }
        }
    
    // prevent different kinds of zeros, by stripping leading duplicate zeroes.
    // digits are in order of increasing significance.
    while ( c->cdigit > 1 && MANT(c)[c->cdigit-1] == 0 )
        {
        c->cdigit--;
        }

    destroynum( *pa );
    *pa=c;
}
//-----------------------------------------------------------------------------
//
//    FUNCTION: numpowlongx
//
//    ARGUMENTS: root as number power as long
//               number.
//
//    RETURN: None root is changed.
//
//    DESCRIPTION: changes numeric representation of root to
//    root ** power. Assumes base BASEX
//    decomposes the exponent into it's sums of powers of 2, so on average
//    it will take n+n/2 multiplies where n is the highest on bit.
//
//-----------------------------------------------------------------------------

void numpowlongx( IN OUT PNUMBER *proot, IN long power )

{
    PNUMBER lret=NULL;

    lret = longtonum( 1, BASEX );

    // Once the power remaining is zero we are done.
    while ( power > 0 )
        {
        // If this bit in the power decomposition is on, multiply the result
        // by the root number.
        if ( power & 1 )
            {
            mulnumx( &lret, *proot );
            }

        // multiply the root number by itself to scale for the next bit (i.e.
        // square it.
        mulnumx( proot, *proot );

        // move the next bit of the power into place.
        power >>= 1;
        }
    destroynum( *proot );
    *proot=lret;
    
}

void _divnumx( PNUMBER *pa, PNUMBER b );

//----------------------------------------------------------------------------
//
//    FUNCTION: divnumx
//
//    ARGUMENTS: pointer to a number a second number.
//
//    RETURN: None, changes first pointer.
//
//    DESCRIPTION: Does the number equivalent of *pa /= b.
//    Assumes nRadix is the internal nRadix representation.
//    This is a stub which prevents division by 1, this is a big speed
//    improvement.
//
//----------------------------------------------------------------------------

void __inline divnumx( PNUMBER *pa, PNUMBER b )

{
    if ( b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0 )
        {
        // b is not one.
        if ( (*pa)->cdigit > 1 || (*pa)->mant[0] != 1 || (*pa)->exp != 0 )
            {
            // pa and b are both not one.
            _divnumx( pa, b );
            }
        else
            {
            // if pa is one and b is not one, just copy b, and adjust the sign.
            long sign = (*pa)->sign;
            DUPNUM(*pa,b);
            (*pa)->sign *= sign;
            }
        }
    else
        {
        // b is one so don't divide, but set the sign.
        (*pa)->sign *= b->sign;
        }
}

//----------------------------------------------------------------------------
//
//    FUNCTION: _divnumx
//
//    ARGUMENTS: pointer to a number a second number.
//
//    RETURN: None, changes first pointer.
//
//    DESCRIPTION: Does the number equivalent of *pa /= b.
//    Assumes nRadix is the internal nRadix representation.
//
//----------------------------------------------------------------------------

void _divnumx( PNUMBER *pa, PNUMBER b )

{
    PNUMBER a=NULL;         // a is the dereferenced number pointer from *pa
    PNUMBER c=NULL;         // c will contain the result.
    PNUMBER lasttmp = NULL; // lasttmp allows a backup when the algorithm
                            // guesses one bit too far.
    PNUMBER tmp = NULL;     // current guess being worked on for divide.
    PNUMBER rem = NULL;     // remainder after applying guess.
    long cdigits;           // count of digits for answer.
    MANTTYPE *ptrc;         // ptrc is a pointer to the mantissa of c.

    long thismax = maxout+ratio; // set a maximum number of internal digits
                                 // to shoot for in the divide.

    a=*pa;
    if ( thismax < a->cdigit )
        {
        // a has more digits than precision specified, bump up digits to shoot 
        // for.
        thismax = a->cdigit;
        }

    if ( thismax < b->cdigit )
        {
        // b has more digits than precision specified, bump up digits to shoot 
        // for.
        thismax = b->cdigit;
        }

    // Create c (the divide answer) and set up exponent and sign.
    createnum( c, thismax + 1 );
    c->exp = (a->cdigit+a->exp) - (b->cdigit+b->exp) + 1;
    c->sign = a->sign * b->sign;

    ptrc = MANT(c) + thismax;
    cdigits = 0;

    DUPNUM( rem, a );
    rem->sign = b->sign;
    rem->exp = b->cdigit + b->exp - rem->cdigit;

    while ( cdigits++ < thismax && !zernum(rem) )
        {
        long digit = 0;
        *ptrc = 0;
        while ( !lessnum( rem, b ) )
            {
            digit = 1;
            DUPNUM( tmp, b );
            destroynum( lasttmp );
            lasttmp=longtonum( 0, BASEX );
            while ( lessnum( tmp, rem ) )
                {
                destroynum( lasttmp );
                DUPNUM(lasttmp,tmp);
                addnum( &tmp, tmp, BASEX );
                digit *= 2;
                }
            if ( lessnum( rem, tmp ) )
                {    
                // too far, back up...
                destroynum( tmp );
                digit /= 2;
                tmp=lasttmp;
                lasttmp=NULL;
                }

            tmp->sign *= -1;
            addnum( &rem, tmp, BASEX ); 
            destroynum( tmp );
            destroynum( lasttmp );
            *ptrc |= digit;
            }
        rem->exp++;
        ptrc--;
        }
    cdigits--;
    if ( MANT(c) != ++ptrc )
        {
        memcpy( MANT(c), ptrc, (int)(cdigits*sizeof(MANTTYPE)) );
        }

    if ( !cdigits )
        {   
        // A zero, make sure no wierd exponents creep in
        c->exp = 0;
        c->cdigit = 1;
        }
    else
        {
        c->cdigit = cdigits;
        c->exp -= cdigits;
        // prevent different kinds of zeros, by stripping leading duplicate 
        // zeroes. digits are in order of increasing significance.
        while ( c->cdigit > 1 && MANT(c)[c->cdigit-1] == 0 )
            {
            c->cdigit--;
            }
        }

    destroynum( rem );

    destroynum( *pa );
    *pa=c;
}