Mass-prefix member vars with m_

1 files changed, 22 insertions, 22 deletions

diff --git a/src/lib/pubkey/ecc_key/ecc_key.cpp b/src/lib/pubkey/ecc_key/ecc_key.cpp
index b0c053688..a3f0ea93d 100644
--- a/src/lib/pubkey/ecc_key/ecc_key.cpp
+++ b/src/lib/pubkey/ecc_key/ecc_key.cpp
@@ -25,8 +25,8 @@ size_t EC_PublicKey::estimated_strength() const
 
 EC_PublicKey::EC_PublicKey(const EC_Group& dom_par,
                            const PointGFp& pub_point) :
-   domain_params(dom_par), public_key(pub_point),
-   domain_encoding(EC_DOMPAR_ENC_EXPLICIT)
+   m_domain_params(dom_par), m_public_key(pub_point),
+   m_domain_encoding(EC_DOMPAR_ENC_EXPLICIT)
    {
    if(domain().get_curve() != public_point().get_curve())
       throw Invalid_Argument("EC_PublicKey: curve mismatch in constructor");
@@ -35,10 +35,10 @@ EC_PublicKey::EC_PublicKey(const EC_Group& dom_par,
 EC_PublicKey::EC_PublicKey(const AlgorithmIdentifier& alg_id,
                            const secure_vector<byte>& key_bits)
    {
-   domain_params = EC_Group(alg_id.parameters);
-   domain_encoding = EC_DOMPAR_ENC_EXPLICIT;
+   m_domain_params = EC_Group(alg_id.parameters);
+   m_domain_encoding = EC_DOMPAR_ENC_EXPLICIT;
 
-   public_key = OS2ECP(key_bits, domain().get_curve());
+   m_public_key = OS2ECP(key_bits, domain().get_curve());
    }
 
 bool EC_PublicKey::check_key(RandomNumberGenerator&,
@@ -64,20 +64,20 @@ void EC_PublicKey::set_parameter_encoding(EC_Group_Encoding form)
       form != EC_DOMPAR_ENC_OID)
       throw Invalid_Argument("Invalid encoding form for EC-key object specified");
 
-   if((form == EC_DOMPAR_ENC_OID) && (domain_params.get_oid() == ""))
+   if((form == EC_DOMPAR_ENC_OID) && (m_domain_params.get_oid() == ""))
       throw Invalid_Argument("Invalid encoding form OID specified for "
                              "EC-key object whose corresponding domain "
                              "parameters are without oid");
 
-   domain_encoding = form;
+   m_domain_encoding = form;
    }
 
 const BigInt& EC_PrivateKey::private_value() const
    {
-   if(private_key == 0)
+   if(m_private_key == 0)
       throw Invalid_State("EC_PrivateKey::private_value - uninitialized");
 
-   return private_key;
+   return m_private_key;
    }
 
 /**
@@ -87,17 +87,17 @@ EC_PrivateKey::EC_PrivateKey(RandomNumberGenerator& rng,
                              const EC_Group& ec_group,
                              const BigInt& x)
    {
-   domain_params = ec_group;
-   domain_encoding = EC_DOMPAR_ENC_EXPLICIT;
+   m_domain_params = ec_group;
+   m_domain_encoding = EC_DOMPAR_ENC_EXPLICIT;
 
    if(x == 0)
-      private_key = BigInt::random_integer(rng, 1, domain().get_order());
+      m_private_key = BigInt::random_integer(rng, 1, domain().get_order());
    else
-      private_key = x;
+      m_private_key = x;
 
-   public_key = domain().get_base_point() * private_key;
+   m_public_key = domain().get_base_point() * m_private_key;
 
-   BOTAN_ASSERT(public_key.on_the_curve(),
+   BOTAN_ASSERT(m_public_key.on_the_curve(),
                 "Generated public key point was on the curve");
    }
 
@@ -106,7 +106,7 @@ secure_vector<byte> EC_PrivateKey::pkcs8_private_key() const
    return DER_Encoder()
       .start_cons(SEQUENCE)
          .encode(static_cast<size_t>(1))
-         .encode(BigInt::encode_1363(private_key, private_key.bytes()),
+         .encode(BigInt::encode_1363(m_private_key, m_private_key.bytes()),
                  OCTET_STRING)
       .end_cons()
       .get_contents();
@@ -115,8 +115,8 @@ secure_vector<byte> EC_PrivateKey::pkcs8_private_key() const
 EC_PrivateKey::EC_PrivateKey(const AlgorithmIdentifier& alg_id,
                              const secure_vector<byte>& key_bits)
    {
-   domain_params = EC_Group(alg_id.parameters);
-   domain_encoding = EC_DOMPAR_ENC_EXPLICIT;
+   m_domain_params = EC_Group(alg_id.parameters);
+   m_domain_encoding = EC_DOMPAR_ENC_EXPLICIT;
 
    OID key_parameters;
    secure_vector<byte> public_key_bits;
@@ -124,7 +124,7 @@ EC_PrivateKey::EC_PrivateKey(const AlgorithmIdentifier& alg_id,
    BER_Decoder(key_bits)
       .start_cons(SEQUENCE)
          .decode_and_check<size_t>(1, "Unknown version code for ECC key")
-         .decode_octet_string_bigint(private_key)
+         .decode_octet_string_bigint(m_private_key)
          .decode_optional(key_parameters, ASN1_Tag(0), PRIVATE)
          .decode_optional_string(public_key_bits, BIT_STRING, 1, PRIVATE)
       .end_cons();
@@ -134,14 +134,14 @@ EC_PrivateKey::EC_PrivateKey(const AlgorithmIdentifier& alg_id,
 
    if(public_key_bits.empty())
       {
-      public_key = domain().get_base_point() * private_key;
+      m_public_key = domain().get_base_point() * m_private_key;
 
-      BOTAN_ASSERT(public_key.on_the_curve(),
+      BOTAN_ASSERT(m_public_key.on_the_curve(),
                    "Public point derived from loaded key was on the curve");
       }
    else
       {
-      public_key = OS2ECP(public_key_bits, domain().get_curve());
+      m_public_key = OS2ECP(public_key_bits, domain().get_curve());
       // OS2ECP verifies that the point is on the curve
       }
    }