block-sha1: move code around

Move the code around so specific architecture hacks are defined first.
Also make one line comments actually one line.  No code change.

Signed-off-by: Nicolas Pitre <nico@cam.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/block-sha1/sha1.c b/block-sha1/sha1.c
index 304cd0452d2d469b6ca2ff36efd54fb805fc70d2..c3f1ae59b9252e499fc8d79dfd0f8fac49bacf2e 100644 (file)
--- a/block-sha1/sha1.c
+++ b/block-sha1/sha1.c
@@ -9,74 +9,6 @@
 
 #include "sha1.h"
 
 
 #include "sha1.h"
 

-/* Hash one 64-byte block of data */
-static void blk_SHA1Block(blk_SHA_CTX *ctx, const unsigned int *data);
-
-void blk_SHA1_Init(blk_SHA_CTX *ctx)
-{
-       ctx->size = 0;
-
-       /* Initialize H with the magic constants (see FIPS180 for constants)
-        */
-       ctx->H[0] = 0x67452301;
-       ctx->H[1] = 0xefcdab89;
-       ctx->H[2] = 0x98badcfe;
-       ctx->H[3] = 0x10325476;
-       ctx->H[4] = 0xc3d2e1f0;
-}
-
-
-void blk_SHA1_Update(blk_SHA_CTX *ctx, const void *data, unsigned long len)
-{
-       int lenW = ctx->size & 63;
-
-       ctx->size += len;
-
-       /* Read the data into W and process blocks as they get full
-        */
-       if (lenW) {
-               int left = 64 - lenW;
-               if (len < left)
-                       left = len;
-               memcpy(lenW + (char *)ctx->W, data, left);
-               lenW = (lenW + left) & 63;
-               len -= left;
-               data += left;
-               if (lenW)
-                       return;
-               blk_SHA1Block(ctx, ctx->W);
-       }
-       while (len >= 64) {
-               blk_SHA1Block(ctx, data);
-               data += 64;
-               len -= 64;
-       }
-       if (len)
-               memcpy(ctx->W, data, len);
-}
-
-
-void blk_SHA1_Final(unsigned char hashout[20], blk_SHA_CTX *ctx)
-{
-       static const unsigned char pad[64] = { 0x80 };
-       unsigned int padlen[2];
-       int i;
-
-       /* Pad with a binary 1 (ie 0x80), then zeroes, then length
-        */
-       padlen[0] = htonl(ctx->size >> 29);
-       padlen[1] = htonl(ctx->size << 3);
-
-       i = ctx->size & 63;
-       blk_SHA1_Update(ctx, pad, 1+ (63 & (55 - i)));
-       blk_SHA1_Update(ctx, padlen, 8);
-
-       /* Output hash
-        */
-       for (i = 0; i < 5; i++)
-               ((unsigned int *)hashout)[i] = htonl(ctx->H[i]);
-}
-

 #if defined(__i386__) || defined(__x86_64__)
 
 #define SHA_ASM(op, x, n) ({ unsigned int __res; __asm__(op " %1,%0":"=r" (__res):"i" (n), "0" (x)); __res; })
 #if defined(__i386__) || defined(__x86_64__)
 
 #define SHA_ASM(op, x, n) ({ unsigned int __res; __asm__(op " %1,%0":"=r" (__res):"i" (n), "0" (x)); __res; })


@@ -136,7 +68,7 @@ void blk_SHA1_Final(unsigned char hashout[20], blk_SHA_CTX *ctx)
 #define T_40_59(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, ((B&C)+(D&(B^C))) , 0x8f1bbcdc, A, B, C, D, E )
 #define T_60_79(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (B^C^D) ,  0xca62c1d6, A, B, C, D, E )
 
 #define T_40_59(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, ((B&C)+(D&(B^C))) , 0x8f1bbcdc, A, B, C, D, E )
 #define T_60_79(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (B^C^D) ,  0xca62c1d6, A, B, C, D, E )
 

-static void blk_SHA1Block(blk_SHA_CTX *ctx, const unsigned int *data)
+static void blk_SHA1_Block(blk_SHA_CTX *ctx, const unsigned int *data)

 {
        unsigned int A,B,C,D,E;
        unsigned int array[16];
 {
        unsigned int A,B,C,D,E;
        unsigned int array[16];


@@ -243,3 +175,62 @@ static void blk_SHA1Block(blk_SHA_CTX *ctx, const unsigned int *data)
        ctx->H[3] += D;
        ctx->H[4] += E;
 }
        ctx->H[3] += D;
        ctx->H[4] += E;
 }

+
+void blk_SHA1_Init(blk_SHA_CTX *ctx)
+{
+       ctx->size = 0;
+
+       /* Initialize H with the magic constants (see FIPS180 for constants) */
+       ctx->H[0] = 0x67452301;
+       ctx->H[1] = 0xefcdab89;
+       ctx->H[2] = 0x98badcfe;
+       ctx->H[3] = 0x10325476;
+       ctx->H[4] = 0xc3d2e1f0;
+}
+
+void blk_SHA1_Update(blk_SHA_CTX *ctx, const void *data, unsigned long len)
+{
+       int lenW = ctx->size & 63;
+
+       ctx->size += len;
+
+       /* Read the data into W and process blocks as they get full */
+       if (lenW) {
+               int left = 64 - lenW;
+               if (len < left)
+                       left = len;
+               memcpy(lenW + (char *)ctx->W, data, left);
+               lenW = (lenW + left) & 63;
+               len -= left;
+               data += left;
+               if (lenW)
+                       return;
+               blk_SHA1_Block(ctx, ctx->W);
+       }
+       while (len >= 64) {
+               blk_SHA1_Block(ctx, data);
+               data += 64;
+               len -= 64;
+       }
+       if (len)
+               memcpy(ctx->W, data, len);
+}
+
+void blk_SHA1_Final(unsigned char hashout[20], blk_SHA_CTX *ctx)
+{
+       static const unsigned char pad[64] = { 0x80 };
+       unsigned int padlen[2];
+       int i;
+
+       /* Pad with a binary 1 (ie 0x80), then zeroes, then length */
+       padlen[0] = htonl(ctx->size >> 29);
+       padlen[1] = htonl(ctx->size << 3);
+
+       i = ctx->size & 63;
+       blk_SHA1_Update(ctx, pad, 1+ (63 & (55 - i)));
+       blk_SHA1_Update(ctx, padlen, 8);
+
+       /* Output hash */
+       for (i = 0; i < 5; i++)
+               ((unsigned int *)hashout)[i] = htonl(ctx->H[i]);
+}