clean up code at crypto folder.

crypto/p224.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This is an implementation of the P224 elliptic curve group. It's written to
 // be short and simple rather than fast, although it's still constant-time.
 //
 // See http://www.imperialviolet.org/2010/12/04/ecc.html ([1]) for background.
 
 #include "crypto/p224.h"
@@ skipping 63 matching lines @@
 
 // Add computes *out = a+b
 //
 // a[i] + b[i] < 2**32
 void Add(FieldElement* out, const FieldElement& a, const FieldElement& b) {
   for (int i = 0; i < 8; i++) {
     (*out)[i] = a[i] + b[i];
   }
 }
 
-static const uint32 kTwo31p3 = (1u<<31) + (1u<<3);
-static const uint32 kTwo31m3 = (1u<<31) - (1u<<3);
-static const uint32 kTwo31m15m3 = (1u<<31) - (1u<<15) - (1u<<3);
+static const uint32 kTwo31p3 = (1u << 31) + (1u << 3);

[agl, 2014/07/21 13:36:10]

I think this is worse because it's really writing 2^31 etc, which is  written
very tightly in math notation.

[rucifer1217, 2014/07/21 16:28:10]

yes, your opinion is right. i will revert code.

+static const uint32 kTwo31m3 = (1u << 31) - (1u << 3);
+static const uint32 kTwo31m15m3 = (1u << 31) - (1u << 15) - (1u << 3);
 // kZero31ModP is 0 mod p where bit 31 is set in all limbs so that we can
 // subtract smaller amounts without underflow. See the section "Subtraction" in
 // [1] for why.
 static const FieldElement kZero31ModP = {
   kTwo31p3, kTwo31m3, kTwo31m3, kTwo31m15m3,
   kTwo31m3, kTwo31m3, kTwo31m3, kTwo31m3
 };
 
 // Subtract computes *out = a-b
 //
@@ skipping 45 matching lines @@
 
   // As the values become small enough, we start to store them in |out| and use
   // 32-bit operations.
   for (int i = 1; i < 8; i++) {
     in[i+1] += in[i] >> 28;
     (*out)[i] = static_cast<uint32>(in[i] & kBottom28Bits);
   }
   // Eliminate the term at 2*224 that we introduced while keeping the same
   // value mod p.
   in[0] -= in[8];  // reflection off the "+1" term of p.
-  (*out)[3] += static_cast<uint32>(in[8] & 0xffff) << 12; // "-2**96" term
+  (*out)[3] += static_cast<uint32>(in[8] & 0xffff) << 12;  // "-2**96" term
   (*out)[4] += static_cast<uint32>(in[8] >> 16);  // rest of "-2**96" term
   // in[0] < 2**64
   // out[3] < 2**29
   // out[4] < 2**29
   // out[1,2,5..7] < 2**28
 
   (*out)[0] = static_cast<uint32>(in[0] & kBottom28Bits);
   (*out)[1] += static_cast<uint32>((in[0] >> 28) & kBottom28Bits);
   (*out)[2] += static_cast<uint32>(in[0] >> 56);
   // out[0] < 2**28
@@ skipping 468 matching lines @@
 void Put224Bits(uint32* out, const uint32* in) {
   out[6] = HostToNet32((in[0] >> 0) | (in[1] << 28));
   out[5] = HostToNet32((in[1] >> 4) | (in[2] << 24));
   out[4] = HostToNet32((in[2] >> 8) | (in[3] << 20));
   out[3] = HostToNet32((in[3] >> 12) | (in[4] << 16));
   out[2] = HostToNet32((in[4] >> 16) | (in[5] << 12));
   out[1] = HostToNet32((in[5] >> 20) | (in[6] << 8));
   out[0] = HostToNet32((in[6] >> 24) | (in[7] << 4));
 }
 
-} // anonymous namespace
+}  // anonymous namespace
 
 namespace crypto {
 
 namespace p224 {
 
 bool Point::SetFromString(const base::StringPiece& in) {
   if (in.size() != 2*28)
     return false;
   const uint32* inwords = reinterpret_cast<const uint32*>(in.data());
   Get224Bits(x, inwords);
@@ skipping 82 matching lines @@
   Subtract(&out->y, kP, y);
   Reduce(&out->y);
 
   memset(&out->z, 0, sizeof(out->z));
   out->z[0] = 1;
 }
 
 }  // namespace p224
 
 }  // namespace crypto