[weiden] 19988: set eol-style to native

set eol-style to native
Modified: trunk/reactos/lib/rtl/i386/alldiv_asm.s
Modified: trunk/reactos/lib/rtl/i386/alldvrm_asm.s
Modified: trunk/reactos/lib/rtl/i386/allmul_asm.s
Modified: trunk/reactos/lib/rtl/i386/allrem_asm.s
Modified: trunk/reactos/lib/rtl/i386/allshl_asm.s
Modified: trunk/reactos/lib/rtl/i386/allshr_asm.s
Modified: trunk/reactos/lib/rtl/i386/atan_asm.s
Modified: trunk/reactos/lib/rtl/i386/aulldiv_asm.s
Modified: trunk/reactos/lib/rtl/i386/aulldvrm_asm.s
Modified: trunk/reactos/lib/rtl/i386/aullrem_asm.s
Modified: trunk/reactos/lib/rtl/i386/aullshr_asm.s
Modified: trunk/reactos/lib/rtl/i386/ceil_asm.s
Modified: trunk/reactos/lib/rtl/i386/comparememory_asm.s
Modified: trunk/reactos/lib/rtl/i386/comparememory_ulong_asm.s
Modified: trunk/reactos/lib/rtl/i386/cos_asm.s
Modified: trunk/reactos/lib/rtl/i386/debug_asm.S
Modified: trunk/reactos/lib/rtl/i386/fabs_asm.s
Modified: trunk/reactos/lib/rtl/i386/fillmemory_asm.s
Modified: trunk/reactos/lib/rtl/i386/fillmemory_ulong_asm.s
Modified: trunk/reactos/lib/rtl/i386/floor_asm.s
Modified: trunk/reactos/lib/rtl/i386/ftol_asm.s
Modified: trunk/reactos/lib/rtl/i386/log_asm.s
Modified: trunk/reactos/lib/rtl/i386/pow_asm.s
Modified: trunk/reactos/lib/rtl/i386/prefetchmemory_asm.s
Modified: trunk/reactos/lib/rtl/i386/random_asm.S
Modified: trunk/reactos/lib/rtl/i386/sin_asm.s
Modified: trunk/reactos/lib/rtl/i386/sqrt_asm.s
Modified: trunk/reactos/lib/rtl/i386/tan_asm.s
Modified: trunk/reactos/lib/rtl/i386/zeromemory_asm.s
  _____  

Modified: trunk/reactos/lib/rtl/i386/alldiv_asm.s
--- trunk/reactos/lib/rtl/i386/alldiv_asm.s	2005-12-08 23:55:34 UTC
(rev 19987)
+++ trunk/reactos/lib/rtl/i386/alldiv_asm.s	2005-12-08 23:56:12 UTC
(rev 19988)
@@ -1,225 +1,225 @@

-/*
- * COPYRIGHT:         See COPYING in the top level directory
- * PROJECT:           ReactOS kernel
- * PURPOSE:           Run-Time Library
- * FILE:              lib/rtl/i386/alldiv_asm.S
- * PROGRAMER:         Alex Ionescu (alex(a)relsoft.net)
- *                    Eric Kohl (ekohl(a)rz-online.de)
- *
- * Copyright (C) 2002 Michael Ringgaard.
- * All rights reserved. 
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * 1. Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer.  
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
the
- *    documentation and/or other materials provided with the
distribution.  
- * 3. Neither the name of the project nor the names of its contributors
- *    may be used to endorse or promote products derived from this
software
- *    without specific prior written permission. 
-
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS
- * OR SERVICES// LOSS OF USE, DATA, OR PROFITS// OR BUSINESS
INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF 
- * SUCH DAMAGE.
- */
- 
- .globl __alldiv
- .globl __fltused
- 
- /* DATA
********************************************************************/
-
-__fltused:
-        .long 0x9875
-
-.intel_syntax noprefix
-
-/* FUNCTIONS
***************************************************************/
-
-//
-// lldiv - signed long divide
-//
-// Purpose:
-//       Does a signed long divide of the arguments.  Arguments are
-//       not changed.
-//
-// Entry:
-//       Arguments are passed on the stack:
-//               1st pushed: divisor (QWORD)
-//               2nd pushed: dividend (QWORD)
-//
-// Exit:
-//       EDX:EAX contains the quotient (dividend/divisor)
-//       NOTE: this routine removes the parameters from the stack.
-//
-// Uses:
-//       ECX
-//
-
-__alldiv:
-
-        push    edi
-        push    esi
-        push    ebx
-
-// Set up the local stack and save the index registers.  When this is
done
-// the stack frame will look as follows (assuming that the expression
a/b will
-// generate a call to lldiv(a, b)):
-//
-//               -----------------
-//               |               |
-//               |---------------|
-//               |               |
-//               |--divisor (b)--|
-//               |               |
-//               |---------------|
-//               |               |
-//               |--dividend (a)-|
-//               |               |
-//               |---------------|
-//               | return addr** |
-//               |---------------|
-//               |      EDI      |
-//               |---------------|
-//               |      ESI      |
-//               |---------------|
-//       ESP---->|      EBX      |
-//               -----------------
-//
-
-#define DVNDLO  [esp + 16]       // stack address of dividend (a)
-#define DVNDHI  [esp + 20]       // stack address of dividend (a)
-#define DVSRLO  [esp + 24]      // stack address of divisor (b)
-#define DVSRHI  [esp + 28]      // stack address of divisor (b)
-
-// Determine sign of the result (edi = 0 if result is positive,
non-zero
-// otherwise) and make operands positive.
-
-        xor     edi,edi         // result sign assumed positive
-
-        mov     eax,DVNDHI // hi word of a
-        or      eax,eax         // test to see if signed
-        jge     short L1        // skip rest if a is already positive
-        inc     edi             // complement result sign flag
-        mov     edx,DVNDLO // lo word of a
-        neg     eax             // make a positive
-        neg     edx
-        sbb     eax,0
-        mov     DVNDHI,eax // save positive value
-        mov     DVNDLO,edx
-L1:
-        mov     eax,DVSRHI // hi word of b
-        or      eax,eax         // test to see if signed
-        jge     short L2        // skip rest if b is already positive
-        inc     edi             // complement the result sign flag
-        mov     edx,DVSRLO // lo word of a
-        neg     eax             // make b positive
-        neg     edx
-        sbb     eax,0
-        mov     DVSRHI,eax // save positive value
-        mov     DVSRLO,edx
-L2:
-
-//
-// Now do the divide.  First look to see if the divisor is less than
4194304K.
-// If so, then we can use a simple algorithm with word divides,
otherwise
-// things get a little more complex.
-//
-// NOTE - eax currently contains the high order word of DVSR
-//
-
-        or      eax,eax         // check to see if divisor < 4194304K
-        jnz     short L3        // nope, gotta do this the hard way
-        mov     ecx,DVSRLO // load divisor
-        mov     eax,DVNDHI // load high word of dividend
-        xor     edx,edx
-        div     ecx             // eax <- high order bits of quotient
-        mov     ebx,eax         // save high bits of quotient
-        mov     eax,DVNDLO // edx:eax <- remainder:lo word of dividend
-        div     ecx             // eax <- low order bits of quotient
-        mov     edx,ebx         // edx:eax <- quotient
-        jmp     short L4        // set sign, restore stack and return
-
-//
-// Here we do it the hard way.  Remember, eax contains the high word of
DVSR
-//
-
-L3:
-        mov     ebx,eax         // ebx:ecx <- divisor
-        mov     ecx,DVSRLO
-        mov     edx,DVNDHI // edx:eax <- dividend
-        mov     eax,DVNDLO
-L5:
-        shr     ebx,1           // shift divisor right one bit
-        rcr     ecx,1
-        shr     edx,1           // shift dividend right one bit
-        rcr     eax,1
-        or      ebx,ebx
-        jnz     short L5        // loop until divisor < 4194304K
-        div     ecx             // now divide, ignore remainder
-        mov     esi,eax         // save quotient
-
-//
-// We may be off by one, so to check, we will multiply the quotient
-// by the divisor and check the result against the orignal dividend
-// Note that we must also check for overflow, which can occur if the
-// dividend is close to 2**64 and the quotient is off by 1.
-//
-
-        mul     dword ptr DVSRHI // QUOT * DVSRHI
-        mov     ecx,eax
-        mov     eax,DVSRLO
-        mul     esi             // QUOT * DVSRLO
-        add     edx,ecx         // EDX:EAX = QUOT * DVSR
-        jc      short L6        // carry means Quotient is off by 1
-
-//
-// do long compare here between original dividend and the result of the
-// multiply in edx:eax.  If original is larger or equal, we are ok,
otherwise
-// subtract one (1) from the quotient.
-//
-
-        cmp     edx,DVNDHI // compare hi words of result and original
-        ja      short L6        // if result > original, do subtract
-        jb      short L7        // if result < original, we are ok
-        cmp     eax,DVNDLO // hi words are equal, compare lo words
-        jbe     short L7        // if less or equal we are ok, else
subtract
-L6:
-        dec     esi             // subtract 1 from quotient
-L7:
-        xor     edx,edx         // edx:eax <- quotient
-        mov     eax,esi
-
-//
-// Just the cleanup left to do.  edx:eax contains the quotient.  Set
the sign
-// according to the save value, cleanup the stack, and return.
-//
-
-L4:
-        dec     edi             // check to see if result is negative
-        jnz     short L8        // if EDI == 0, result should be
negative
-        neg     edx             // otherwise, negate the result
-        neg     eax
-        sbb     edx,0
-
-//
-// Restore the saved registers and return.
-//
-
-L8:
-        pop     ebx
-        pop     esi
-        pop     edi
-
-        ret     16
+/*
+ * COPYRIGHT:         See COPYING in the top level directory
+ * PROJECT:           ReactOS kernel
+ * PURPOSE:           Run-Time Library
+ * FILE:              lib/rtl/i386/alldiv_asm.S
+ * PROGRAMER:         Alex Ionescu (alex(a)relsoft.net)
+ *                    Eric Kohl (ekohl(a)rz-online.de)
+ *
+ * Copyright (C) 2002 Michael Ringgaard.
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.  
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
the
+ *    documentation and/or other materials provided with the
distribution.  
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this
software
+ *    without specific prior written permission. 
+
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS
+ * OR SERVICES// LOSS OF USE, DATA, OR PROFITS// OR BUSINESS
INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF 
+ * SUCH DAMAGE.
+ */
+ 
+ .globl __alldiv
+ .globl __fltused
+ 
+ /* DATA
********************************************************************/
+
+__fltused:
+        .long 0x9875
+
+.intel_syntax noprefix
+
+/* FUNCTIONS
***************************************************************/
+
+//
+// lldiv - signed long divide
+//
+// Purpose:
+//       Does a signed long divide of the arguments.  Arguments are
+//       not changed.
+//
+// Entry:
+//       Arguments are passed on the stack:
+//               1st pushed: divisor (QWORD)
+//               2nd pushed: dividend (QWORD)
+//
+// Exit:
+//       EDX:EAX contains the quotient (dividend/divisor)
+//       NOTE: this routine removes the parameters from the stack.
+//
+// Uses:
+//       ECX
+//
+
+__alldiv:
+
+        push    edi
+        push    esi
+        push    ebx
+
+// Set up the local stack and save the index registers.  When this is
done
+// the stack frame will look as follows (assuming that the expression
a/b will
+// generate a call to lldiv(a, b)):
+//
+//               -----------------
+//               |               |
+//               |---------------|
+//               |               |
+//               |--divisor (b)--|
+//               |               |
+//               |---------------|
+//               |               |
+//               |--dividend (a)-|
+//               |               |
+//               |---------------|
+//               | return addr** |
+//               |---------------|
+//               |      EDI      |
+//               |---------------|
+//               |      ESI      |
+//               |---------------|
+//       ESP---->|      EBX      |
+//               -----------------
+//
+
+#define DVNDLO  [esp + 16]       // stack address of dividend (a)
+#define DVNDHI  [esp + 20]       // stack address of dividend (a)
+#define DVSRLO  [esp + 24]      // stack address of divisor (b)
+#define DVSRHI  [esp + 28]      // stack address of divisor (b)
+
+// Determine sign of the result (edi = 0 if result is positive,
non-zero
+// otherwise) and make operands positive.
+
+        xor     edi,edi         // result sign assumed positive
+
+        mov     eax,DVNDHI // hi word of a
+        or      eax,eax         // test to see if signed
+        jge     short L1        // skip rest if a is already positive
+        inc     edi             // complement result sign flag
+        mov     edx,DVNDLO // lo word of a
+        neg     eax             // make a positive
+        neg     edx
+        sbb     eax,0
+        mov     DVNDHI,eax // save positive value
+        mov     DVNDLO,edx
+L1:
+        mov     eax,DVSRHI // hi word of b
+        or      eax,eax         // test to see if signed
+        jge     short L2        // skip rest if b is already positive
+        inc     edi             // complement the result sign flag
+        mov     edx,DVSRLO // lo word of a
+        neg     eax             // make b positive
+        neg     edx
+        sbb     eax,0
+        mov     DVSRHI,eax // save positive value
+        mov     DVSRLO,edx
+L2:
+
+//
+// Now do the divide.  First look to see if the divisor is less than
4194304K.
+// If so, then we can use a simple algorithm with word divides,
otherwise
+// things get a little more complex.
+//
+// NOTE - eax currently contains the high order word of DVSR
+//
+
+        or      eax,eax         // check to see if divisor < 4194304K
+        jnz     short L3        // nope, gotta do this the hard way
+        mov     ecx,DVSRLO // load divisor
+        mov     eax,DVNDHI // load high word of dividend
+        xor     edx,edx
+        div     ecx             // eax <- high order bits of quotient
+        mov     ebx,eax         // save high bits of quotient
+        mov     eax,DVNDLO // edx:eax <- remainder:lo word of dividend
+        div     ecx             // eax <- low order bits of quotient
+        mov     edx,ebx         // edx:eax <- quotient
+        jmp     short L4        // set sign, restore stack and return
+
+//
+// Here we do it the hard way.  Remember, eax contains the high word of
DVSR
+//
+
+L3:
+        mov     ebx,eax         // ebx:ecx <- divisor
+        mov     ecx,DVSRLO
+        mov     edx,DVNDHI // edx:eax <- dividend
+        mov     eax,DVNDLO
+L5:
+        shr     ebx,1           // shift divisor right one bit
+        rcr     ecx,1
+        shr     edx,1           // shift dividend right one bit
+        rcr     eax,1
+        or      ebx,ebx
+        jnz     short L5        // loop until divisor < 4194304K
+        div     ecx             // now divide, ignore remainder
+        mov     esi,eax         // save quotient
+
+//
+// We may be off by one, so to check, we will multiply the quotient
+// by the divisor and check the result against the orignal dividend
+// Note that we must also check for overflow, which can occur if the
+// dividend is close to 2**64 and the quotient is off by 1.
+//
+
+        mul     dword ptr DVSRHI // QUOT * DVSRHI
+        mov     ecx,eax
+        mov     eax,DVSRLO
+        mul     esi             // QUOT * DVSRLO
+        add     edx,ecx         // EDX:EAX = QUOT * DVSR
+        jc      short L6        // carry means Quotient is off by 1
+
+//
+// do long compare here between original dividend and the result of the
+// multiply in edx:eax.  If original is larger or equal, we are ok,
otherwise
+// subtract one (1) from the quotient.
+//
+
+        cmp     edx,DVNDHI // compare hi words of result and original
+        ja      short L6        // if result > original, do subtract
+        jb      short L7        // if result < original, we are ok
+        cmp     eax,DVNDLO // hi words are equal, compare lo words
+        jbe     short L7        // if less or equal we are ok, else
subtract
+L6:
+        dec     esi             // subtract 1 from quotient
+L7:
+        xor     edx,edx         // edx:eax <- quotient
+        mov     eax,esi
+
+//
+// Just the cleanup left to do.  edx:eax contains the quotient.  Set
the sign
+// according to the save value, cleanup the stack, and return.
+//
+
+L4:
+        dec     edi             // check to see if result is negative
+        jnz     short L8        // if EDI == 0, result should be
negative
+        neg     edx             // otherwise, negate the result
+        neg     eax
+        sbb     edx,0
+
+//
+// Restore the saved registers and return.
+//
+
+L8:
+        pop     ebx
+        pop     esi
+        pop     edi
+
+        ret     16
Property changes on: trunk/reactos/lib/rtl/i386/alldiv_asm.s
___________________________________________________________________
Name: svn:eol-style
   + native
  _____  

Modified: trunk/reactos/lib/rtl/i386/alldvrm_asm.s
--- trunk/reactos/lib/rtl/i386/alldvrm_asm.s	2005-12-08 23:55:34 UTC
(rev 19987)
+++ trunk/reactos/lib/rtl/i386/alldvrm_asm.s	2005-12-08 23:56:12 UTC
(rev 19988)
@@ -1,247 +1,247 @@

-/*
- * COPYRIGHT:         See COPYING in the top level directory
- * PROJECT:           ReactOS kernel
- * PURPOSE:           Run-Time Library
- * FILE:              lib/rtl/i386/alldvrm.S
- * PROGRAMER:         Alex Ionescu (alex(a)relsoft.net)
- *                    Eric Kohl (ekohl(a)rz-online.de)
- *
- * Copyright (C) 2002 Michael Ringgaard.
- * All rights reserved. 
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * 1. Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer.  
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
the
- *    documentation and/or other materials provided with the
distribution.  
- * 3. Neither the name of the project nor the names of its contributors
- *    may be used to endorse or promote products derived from this
software
- *    without specific prior written permission. 
-
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS
- * OR SERVICES// LOSS OF USE, DATA, OR PROFITS// OR BUSINESS
INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF 
- * SUCH DAMAGE.
- */
- 
-.globl __alldvrm
- 
-.intel_syntax noprefix
-
-/* FUNCTIONS
***************************************************************/
-
-__alldvrm:
-        push    edi
-        push    esi
-        push    ebp
-
-// Set up the local stack and save the index registers.  When this is
done
-// the stack frame will look as follows (assuming that the expression
a/b will
-// generate a call to alldvrm(a, b)):
-//
-//               -----------------
-//               |               |
-//               |---------------|
-//               |               |
-//               |--divisor (b)--|
-//               |               |
-//               |---------------|
-//               |               |
-//               |--dividend (a)-|
-//               |               |
-//               |---------------|
-//               | return addr** |
-//               |---------------|
-//               |      EDI      |
-//               |---------------|
-//               |      ESI      |
-//               |---------------|
-//       ESP---->|      EBP      |
-//               -----------------
-//
-
-#undef DVNDLO
-#undef DVNDHI
-#undef DVSRLO
-#undef DVSRHI
-#define DVNDLO  [esp + 16]       // stack address of dividend (a)
-#define DVNDHI  [esp + 20]       // stack address of dividend (a)
-#define DVSRLO  [esp + 24]      // stack address of divisor (b)
-#define DVSRHI  [esp + 28]      // stack address of divisor (b)
-
-// Determine sign of the quotient (edi = 0 if result is positive,
non-zero
-// otherwise) and make operands positive.
-// Sign of the remainder is kept in ebp.
-
-        xor     edi,edi         // result sign assumed positive
-        xor     ebp,ebp         // result sign assumed positive
-
-        mov     eax,DVNDHI // hi word of a
-        or      eax,eax         // test to see if signed
-        jge     short ....L1        // skip rest if a is already
positive
-        inc     edi             // complement result sign flag
-        inc     ebp             // complement result sign flag
-        mov     edx,DVNDLO // lo word of a
-        neg     eax             // make a positive
-        neg     edx
-        sbb     eax,0
-        mov     DVNDHI,eax // save positive value
-        mov     DVNDLO,edx
-....L1:
-        mov     eax,DVSRHI // hi word of b
-        or      eax,eax         // test to see if signed
-        jge     short ....L2        // skip rest if b is already
positive
-        inc     edi             // complement the result sign flag
-        mov     edx,DVSRLO // lo word of a
-        neg     eax             // make b positive
-        neg     edx
-        sbb     eax,0
-        mov     DVSRHI,eax // save positive value
-        mov     DVSRLO,edx
-....L2:
-
-//
-// Now do the divide.  First look to see if the divisor is less than
4194304K.
-// If so, then we can use a simple algorithm with word divides,
otherwise
-// things get a little more complex.
-//
-// NOTE - eax currently contains the high order word of DVSR
-//
-
-        or      eax,eax         // check to see if divisor < 4194304K
-        jnz     short ....L3        // nope, gotta do this the hard way
-        mov     ecx,DVSRLO // load divisor
-        mov     eax,DVNDHI // load high word of dividend
-        xor     edx,edx
-        div     ecx             // eax <- high order bits of quotient
-        mov     ebx,eax         // save high bits of quotient
-        mov     eax,DVNDLO // edx:eax <- remainder:lo word of dividend
-        div     ecx             // eax <- low order bits of quotient
-        mov     esi,eax         // ebx:esi <- quotient
-//
-// Now we need to do a multiply so that we can compute the remainder.
-//
-        mov     eax,ebx         // set up high word of quotient
-        mul     dword ptr DVSRLO // HIWORD(QUOT) * DVSR
-        mov     ecx,eax         // save the result in ecx
-        mov     eax,esi         // set up low word of quotient
-        mul     dword ptr DVSRLO // LOWORD(QUOT) * DVSR
-        add     edx,ecx         // EDX:EAX = QUOT * DVSR
-        jmp     short ....L4        // complete remainder calculation
-
-//
-// Here we do it the hard way.  Remember, eax contains the high word of
DVSR
-//
-
-....L3:
-        mov     ebx,eax         // ebx:ecx <- divisor
-        mov     ecx,DVSRLO
-        mov     edx,DVNDHI // edx:eax <- dividend
-        mov     eax,DVNDLO
-....L5:
-        shr     ebx,1           // shift divisor right one bit
-        rcr     ecx,1
-        shr     edx,1           // shift dividend right one bit
-        rcr     eax,1
-        or      ebx,ebx
-        jnz     short ....L5        // loop until divisor < 4194304K
-        div     ecx             // now divide, ignore remainder
-        mov     esi,eax         // save quotient
-
-//
-// We may be off by one, so to check, we will multiply the quotient
-// by the divisor and check the result against the orignal dividend
-// Note that we must also check for overflow, which can occur if the
-// dividend is close to 2**64 and the quotient is off by 1.
-//
-
-        mul     dword ptr DVSRHI // QUOT * DVSRHI
-        mov     ecx,eax
-        mov     eax,DVSRLO
-        mul     esi             // QUOT * DVSRLO
-        add     edx,ecx         // EDX:EAX = QUOT * DVSR
-        jc      short ....L6        // carry means Quotient is off by 1
-
-//
-// do long compare here between original dividend and the result of the
-// multiply in edx:eax.  If original is larger or equal, we are ok,
otherwise
-// subtract one (1) from the quotient.
-//
-
-        cmp     edx,DVNDHI // compare hi words of result and original
-        ja      short ....L6        // if result > original, do
subtract
-        jb      short ....L7        // if result < original, we are ok
-        cmp     eax,DVNDLO // hi words are equal, compare lo words
-        jbe     short ....L7        // if less or equal we are ok, else
subtract
-....L6:
-        dec     esi             // subtract 1 from quotient
-        sub     eax,DVSRLO // subtract divisor from result
-        sbb     edx,DVSRHI
-....L7:
-        xor     ebx,ebx         // ebx:esi <- quotient
-
-....L4:
-//
-// Calculate remainder by subtracting the result from the original
dividend.
-// Since the result is already in a register, we will do the subtract
in the
-// opposite direction and negate the result if necessary.
-//
-
-        sub     eax,DVNDLO // subtract dividend from result
-        sbb     edx,DVNDHI
-
-//
-// Now check the result sign flag to see if the result is supposed to
be positive
-// or negative.  It is currently negated (because we subtracted in the
'wrong'
-// direction), so if the sign flag is set we are done, otherwise we
must negate
-// the result to make it positive again.
-//
-
-        dec     ebp             // check result sign flag
-        jns     short ....L9        // result is ok, set up the
quotient
-        neg     edx             // otherwise, negate the result
-        neg     eax
-        sbb     edx,0
-
-//
-// Now we need to get the quotient into edx:eax and the remainder into
ebx:ecx.
-//
-....L9:
-        mov     ecx,edx
-        mov     edx,ebx
-        mov     ebx,ecx
-        mov     ecx,eax
-        mov     eax,esi
-
-//
-// Just the cleanup left to do.  edx:eax contains the quotient.  Set
the sign
-// according to the save value, cleanup the stack, and return.
-//
-
-        dec     edi             // check to see if result is negative
-        jnz     short ....L8        // if EDI == 0, result should be
negative
-        neg     edx             // otherwise, negate the result
-        neg     eax
-        sbb     edx,0
-
-//
-// Restore the saved registers and return.
-//
-
-....L8:
-        pop     ebp
-        pop     esi
-        pop     edi
-
-        ret     16
+/*
+ * COPYRIGHT:         See COPYING in the top level directory
+ * PROJECT:           ReactOS kernel
+ * PURPOSE:           Run-Time Library
+ * FILE:              lib/rtl/i386/alldvrm.S
+ * PROGRAMER:         Alex Ionescu (alex(a)relsoft.net)
+ *                    Eric Kohl (ekohl(a)rz-online.de)
+ *
+ * Copyright (C) 2002 Michael Ringgaard.
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.  
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
the
+ *    documentation and/or other materials provided with the
distribution.  
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this
software
+ *    without specific prior written permission. 
+
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS
+ * OR SERVICES// LOSS OF USE, DATA, OR PROFITS// OR BUSINESS
INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF 
+ * SUCH DAMAGE.
+ */
+ 
+.globl __alldvrm
+ 
+.intel_syntax noprefix
+
+/* FUNCTIONS
***************************************************************/
+
+__alldvrm:
+        push    edi
+        push    esi
+        push    ebp
+
+// Set up the local stack and save the index registers.  When this is
done
+// the stack frame will look as follows (assuming that the expression
a/b will
+// generate a call to alldvrm(a, b)):
+//
+//               -----------------
+//               |               |
+//               |---------------|
+//               |               |
+//               |--divisor (b)--|
+//               |               |
+//               |---------------|
+//               |               |
+//               |--dividend (a)-|
+//               |               |
+//               |---------------|
+//               | return addr** |
+//               |---------------|
+//               |      EDI      |
+//               |---------------|
+//               |      ESI      |
+//               |---------------|
+//       ESP---->|      EBP      |
+//               -----------------
+//
+
+#undef DVNDLO
+#undef DVNDHI
+#undef DVSRLO
+#undef DVSRHI
+#define DVNDLO  [esp + 16]       // stack address of dividend (a)
+#define DVNDHI  [esp + 20]       // stack address of dividend (a)
+#define DVSRLO  [esp + 24]      // stack address of divisor (b)
+#define DVSRHI  [esp + 28]      // stack address of divisor (b)
+
+// Determine sign of the quotient (edi = 0 if result is positive,
non-zero
+// otherwise) and make operands positive.
+// Sign of the remainder is kept in ebp.
+
+        xor     edi,edi         // result sign assumed positive
+        xor     ebp,ebp         // result sign assumed positive
+
+        mov     eax,DVNDHI // hi word of a
+        or      eax,eax         // test to see if signed
+        jge     short ....L1        // skip rest if a is already
positive
+        inc     edi             // complement result sign flag
+        inc     ebp             // complement result sign flag
+        mov     edx,DVNDLO // lo word of a
+        neg     eax             // make a positive
+        neg     edx
+        sbb     eax,0
+        mov     DVNDHI,eax // save positive value
+        mov     DVNDLO,edx
+....L1:
+        mov     eax,DVSRHI // hi word of b
+        or      eax,eax         // test to see if signed
+        jge     short ....L2        // skip rest if b is already
positive
+        inc     edi             // complement the result sign flag
+        mov     edx,DVSRLO // lo word of a
+        neg     eax             // make b positive
+        neg     edx
+        sbb     eax,0
+        mov     DVSRHI,eax // save positive value
+        mov     DVSRLO,edx
+....L2:
+
+//
+// Now do the divide.  First look to see if the divisor is less than
4194304K.
+// If so, then we can use a simple algorithm with word divides,
otherwise
+// things get a little more complex.
+//
+// NOTE - eax currently contains the high order word of DVSR
+//
+
+        or      eax,eax         // check to see if divisor < 4194304K
+        jnz     short ....L3        // nope, gotta do this the hard way
+        mov     ecx,DVSRLO // load divisor
+        mov     eax,DVNDHI // load high word of dividend
+        xor     edx,edx
+        div     ecx             // eax <- high order bits of quotient
+        mov     ebx,eax         // save high bits of quotient
+        mov     eax,DVNDLO // edx:eax <- remainder:lo word of dividend
+        div     ecx             // eax <- low order bits of quotient
+        mov     esi,eax         // ebx:esi <- quotient
+//
+// Now we need to do a multiply so that we can compute the remainder.
+//
+        mov     eax,ebx         // set up high word of quotient
+        mul     dword ptr DVSRLO // HIWORD(QUOT) * DVSR
+        mov     ecx,eax         // save the result in ecx
+        mov     eax,esi         // set up low word of quotient
+        mul     dword ptr DVSRLO // LOWORD(QUOT) * DVSR
+        add     edx,ecx         // EDX:EAX = QUOT * DVSR
+        jmp     short ....L4        // complete remainder calculation
+
+//
+// Here we do it the hard way.  Remember, eax contains the high word of
DVSR
+//
+
+....L3:
+        mov     ebx,eax         // ebx:ecx <- divisor
+        mov     ecx,DVSRLO
+        mov     edx,DVNDHI // edx:eax <- dividend
+        mov     eax,DVNDLO
+....L5:
+        shr     ebx,1           // shift divisor right one bit
+        rcr     ecx,1
+        shr     edx,1           // shift dividend right one bit
+        rcr     eax,1
+        or      ebx,ebx
+        jnz     short ....L5        // loop until divisor < 4194304K
+        div     ecx             // now divide, ignore remainder
+        mov     esi,eax         // save quotient
+
+//
+// We may be off by one, so to check, we will multiply the quotient
+// by the divisor and check the result against the orignal dividend
+// Note that we must also check for overflow, which can occur if the
+// dividend is close to 2**64 and the quotient is off by 1.
+//
+
+        mul     dword ptr DVSRHI // QUOT * DVSRHI
+        mov     ecx,eax
+        mov     eax,DVSRLO
+        mul     esi             // QUOT * DVSRLO
+        add     edx,ecx         // EDX:EAX = QUOT * DVSR
+        jc      short ....L6        // carry means Quotient is off by 1
+
+//
+// do long compare here between original dividend and the result of the
+// multiply in edx:eax.  If original is larger or equal, we are ok,
otherwise
+// subtract one (1) from the quotient.
+//
+
+        cmp     edx,DVNDHI // compare hi words of result and original
+        ja      short ....L6        // if result > original, do
subtract
+        jb      short ....L7        // if result < original, we are ok
+        cmp     eax,DVNDLO // hi words are equal, compare lo words
+        jbe     short ....L7        // if less or equal we are ok, else
subtract
+....L6:
+        dec     esi             // subtract 1 from quotient
+        sub     eax,DVSRLO // subtract divisor from result
+        sbb     edx,DVSRHI
+....L7:
+        xor     ebx,ebx         // ebx:esi <- quotient
+
+....L4:
+//
+// Calculate remainder by subtracting the result from the original
dividend.
+// Since the result is already in a register, we will do the subtract
in the
+// opposite direction and negate the result if necessary.
+//
+
+        sub     eax,DVNDLO // subtract dividend from result
+        sbb     edx,DVNDHI
+
+//
+// Now check the result sign flag to see if the result is supposed to
be positive
+// or negative.  It is currently negated (because we subtracted in the
'wrong'
+// direction), so if the sign flag is set we are done, otherwise we
must negate
+// the result to make it positive again.
+//
+
+        dec     ebp             // check result sign flag
+        jns     short ....L9        // result is ok, set up the
quotient
+        neg     edx             // otherwise, negate the result
+        neg     eax
+        sbb     edx,0
+
+//
+// Now we need to get the quotient into edx:eax and the remainder into
ebx:ecx.
+//
+....L9:
+        mov     ecx,edx
+        mov     edx,ebx
+        mov     ebx,ecx
+        mov     ecx,eax
+        mov     eax,esi
+
+//
+// Just the cleanup left to do.  edx:eax contains the quotient.  Set
the sign
+// according to the save value, cleanup the stack, and return.
+//
+
+        dec     edi             // check to see if result is negative
+        jnz     short ....L8        // if EDI == 0, result should be
negative
+        neg     edx             // otherwise, negate the result
+        neg     eax
+        sbb     edx,0
+
+//
+// Restore the saved registers and return.
+//
+
+....L8:
+        pop     ebp
+        pop     esi
+        pop     edi
+
+        ret     16
Property changes on: trunk/reactos/lib/rtl/i386/alldvrm_asm.s
___________________________________________________________________
Name: svn:eol-style
   + native
  _____  

Modified: trunk/reactos/lib/rtl/i386/allmul_asm.s
--- trunk/reactos/lib/rtl/i386/allmul_asm.s	2005-12-08 23:55:34 UTC
(rev 19987)
+++ trunk/reactos/lib/rtl/i386/allmul_asm.s	2005-12-08 23:56:12 UTC
(rev 19988)
@@ -1,116 +1,116 @@

-/*
- * COPYRIGHT:         See COPYING in the top level directory
- * PROJECT:           ReactOS kernel
- * PURPOSE:           Run-Time Library
- * FILE:              lib/rtl/i386/allmul.S
- * PROGRAMER:         Alex Ionescu (alex(a)relsoft.net)
- *                    Eric Kohl (ekohl(a)rz-online.de)
- *
- * Copyright (C) 2002 Michael Ringgaard.
- * All rights reserved. 
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * 1. Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer.  
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
the
- *    documentation and/or other materials provided with the
distribution.  
- * 3. Neither the name of the project nor the names of its contributors
- *    may be used to endorse or promote products derived from this
software
- *    without specific prior written permission. 
-
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS
- * OR SERVICES// LOSS OF USE, DATA, OR PROFITS// OR BUSINESS
INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY
[truncated at 1000 lines; 5077 more skipped]