win vs2015: avoid some variable shadowing warnings in crypto/p224

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 457 matching lines @@
   // S2 = Y2*Z1*Z1Z1
   Mul(&s2, a.z, z1z1);
   Mul(&s2, b.y, s2);
 
   // H = U2-U1
   Subtract(&h, u2, u1);
   Reduce(&h);
   uint32 x_equal = IsZero(h);
 
   // I = (2*H)²
-  for (int j = 0; j < 8; j++) {
-    i[j] = h[j] << 1;
+  for (int k = 0; k < 8; k++) {
+    i[k] = h[k] << 1;
   }
   Reduce(&i);
   Square(&i, i);
 
   // J = H*I
   Mul(&j, h, i);
   // r = 2*(S2-S1)
   Subtract(&r, s2, s1);
   Reduce(&r);
   uint32 y_equal = IsZero(r);
 
   if (x_equal && y_equal && !z1_is_zero && !z2_is_zero) {
     // The two input points are the same therefore we must use the dedicated
     // doubling function as the slope of the line is undefined.
     DoubleJacobian(out, a);
     return;
   }
 
-  for (int i = 0; i < 8; i++) {
-    r[i] <<= 1;
+  for (int k = 0; k < 8; k++) {
+    r[k] <<= 1;
   }
   Reduce(&r);
 
   // V = U1*I
   Mul(&v, u1, i);
 
   // Z3 = ((Z1+Z2)²-Z1Z1-Z2Z2)*H
   Add(&z1z1, z1z1, z2z2);
   Add(&z2z2, a.z, b.z);
   Reduce(&z2z2);
   Square(&z2z2, z2z2);
   Subtract(&out->z, z2z2, z1z1);
   Reduce(&out->z);
   Mul(&out->z, out->z, h);
 
   // X3 = r²-J-2*V
-  for (int i = 0; i < 8; i++) {
-    z1z1[i] = v[i] << 1;
+  for (int k = 0; k < 8; k++) {
+    z1z1[k] = v[k] << 1;
   }
   Add(&z1z1, j, z1z1);
   Reduce(&z1z1);
   Square(&out->x, r);
   Subtract(&out->x, out->x, z1z1);
   Reduce(&out->x);
 
   // Y3 = r*(V-X3)-2*S1*J
-  for (int i = 0; i < 8; i++) {
-    s1[i] <<= 1;
+  for (int k = 0; k < 8; k++) {
+    s1[k] <<= 1;
   }
   Mul(&s1, s1, j);
   Subtract(&z1z1, v, out->x);
   Reduce(&z1z1);
   Mul(&z1z1, z1z1, r);
   Subtract(&out->y, z1z1, s1);
   Reduce(&out->y);
 
   CopyConditional(out, a, z2_is_zero);
   CopyConditional(out, b, z1_is_zero);
@@ skipping 146 matching lines @@
   Reduce(&three_x);
   Subtract(&rhs, rhs, three_x);
   Reduce(&rhs);
 
   ::Add(&rhs, rhs, kB);
   Contract(&rhs);
   return memcmp(&lhs, &rhs, sizeof(lhs)) == 0;
 }
 
 std::string Point::ToString() const {
-  FieldElement zinv, zinv_sq, x, y;
+  FieldElement zinv, zinv_sq, xx, yy;
 
   // If this is the point at infinity we return a string of all zeros.
   if (IsZero(this->z)) {
     static const char zeros[56] = {0};
     return std::string(zeros, sizeof(zeros));
   }
 
   Invert(&zinv, this->z);
   Square(&zinv_sq, zinv);
-  Mul(&x, this->x, zinv_sq);
+  Mul(&xx, x, zinv_sq);
   Mul(&zinv_sq, zinv_sq, zinv);
-  Mul(&y, this->y, zinv_sq);
+  Mul(&yy, y, zinv_sq);
 
-  Contract(&x);
-  Contract(&y);
+  Contract(&xx);
+  Contract(&yy);
 
   uint32 outwords[14];
-  Put224Bits(outwords, x);
-  Put224Bits(outwords + 7, y);
+  Put224Bits(outwords, xx);
+  Put224Bits(outwords + 7, yy);
   return std::string(reinterpret_cast<const char*>(outwords), sizeof(outwords));
 }
 
 void ScalarMult(const Point& in, const uint8* scalar, Point* out) {
   ::ScalarMult(out, in, scalar, 28);
 }
 
 // kBasePoint is the base point (generator) of the elliptic curve group.
 static const Point kBasePoint = {
   {22813985, 52956513, 34677300, 203240812,
@@ skipping 25 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