Merge #8655: Do not shadow variables (trivials)

laanwj · laanwj · commit 920ca1f0bf0b · 2016-09-27T13:25:54.000+02:00
4731cab Do not shadow variables (Pavel Janík)
diff --git a/src/bloom.cpp b/src/bloom.cpp
@@ -280,8 +280,8 @@ void CRollingBloomFilter::insert(const std::vector<unsigned char>& vKey)
 
 void CRollingBloomFilter::insert(const uint256& hash)
 {
-    vector<unsigned char> data(hash.begin(), hash.end());
-    insert(data);
+    vector<unsigned char> vData(hash.begin(), hash.end());
+    insert(vData);
 }
 
 bool CRollingBloomFilter::contains(const std::vector<unsigned char>& vKey) const
@@ -300,8 +300,8 @@ bool CRollingBloomFilter::contains(const std::vector<unsigned char>& vKey) const
 
 bool CRollingBloomFilter::contains(const uint256& hash) const
 {
-    vector<unsigned char> data(hash.begin(), hash.end());
-    return contains(data);
+    vector<unsigned char> vData(hash.begin(), hash.end());
+    return contains(vData);
 }
 
 void CRollingBloomFilter::reset()
diff --git a/src/key.cpp b/src/key.cpp
@@ -243,12 +243,12 @@ bool CKey::Derive(CKey& keyChild, ChainCode &ccChild, unsigned int nChild, const
     return ret;
 }
 
-bool CExtKey::Derive(CExtKey &out, unsigned int nChild) const {
+bool CExtKey::Derive(CExtKey &out, unsigned int _nChild) const {
     out.nDepth = nDepth + 1;
     CKeyID id = key.GetPubKey().GetID();
     memcpy(&out.vchFingerprint[0], &id, 4);
-    out.nChild = nChild;
-    return key.Derive(out.key, out.chaincode, nChild, chaincode);
+    out.nChild = _nChild;
+    return key.Derive(out.key, out.chaincode, _nChild, chaincode);
 }
 
 void CExtKey::SetMaster(const unsigned char *seed, unsigned int nSeedLen) {
diff --git a/src/main.cpp b/src/main.cpp
@@ -1185,9 +1185,9 @@ bool AcceptToMemoryPoolWorker(CTxMemPool& pool, CValidationState& state, const C
                 bool fReplacementOptOut = true;
                 if (fEnableReplacement)
                 {
-                    BOOST_FOREACH(const CTxIn &txin, ptxConflicting->vin)
+                    BOOST_FOREACH(const CTxIn &_txin, ptxConflicting->vin)
                     {
-                        if (txin.nSequence < std::numeric_limits<unsigned int>::max()-1)
+                        if (_txin.nSequence < std::numeric_limits<unsigned int>::max()-1)
                         {
                             fReplacementOptOut = false;
                             break;
@@ -2499,14 +2499,14 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
     if (pindex->GetUndoPos().IsNull() || !pindex->IsValid(BLOCK_VALID_SCRIPTS))
     {
         if (pindex->GetUndoPos().IsNull()) {
-            CDiskBlockPos pos;
-            if (!FindUndoPos(state, pindex->nFile, pos, ::GetSerializeSize(blockundo, SER_DISK, CLIENT_VERSION) + 40))
+            CDiskBlockPos _pos;
+            if (!FindUndoPos(state, pindex->nFile, _pos, ::GetSerializeSize(blockundo, SER_DISK, CLIENT_VERSION) + 40))
                 return error("ConnectBlock(): FindUndoPos failed");
-            if (!UndoWriteToDisk(blockundo, pos, pindex->pprev->GetBlockHash(), chainparams.MessageStart()))
+            if (!UndoWriteToDisk(blockundo, _pos, pindex->pprev->GetBlockHash(), chainparams.MessageStart()))
                 return AbortNode(state, "Failed to write undo data");
 
             // update nUndoPos in block index
-            pindex->nUndoPos = pos.nPos;
+            pindex->nUndoPos = _pos.nPos;
             pindex->nStatus |= BLOCK_HAVE_UNDO;
         }
 
@@ -3819,10 +3819,10 @@ void PruneOneBlockFile(const int fileNumber)
             // mapBlocksUnlinked or setBlockIndexCandidates.
             std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range = mapBlocksUnlinked.equal_range(pindex->pprev);
             while (range.first != range.second) {
-                std::multimap<CBlockIndex *, CBlockIndex *>::iterator it = range.first;
+                std::multimap<CBlockIndex *, CBlockIndex *>::iterator _it = range.first;
                 range.first++;
-                if (it->second == pindex) {
-                    mapBlocksUnlinked.erase(it);
+                if (_it->second == pindex) {
+                    mapBlocksUnlinked.erase(_it);
                 }
             }
         }
@@ -5550,9 +5550,9 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
             }
             if (!fRejectedParents) {
                 BOOST_FOREACH(const CTxIn& txin, tx.vin) {
-                    CInv inv(MSG_TX, txin.prevout.hash);
-                    pfrom->AddInventoryKnown(inv);
-                    if (!AlreadyHave(inv)) pfrom->AskFor(inv);
+                    CInv _inv(MSG_TX, txin.prevout.hash);
+                    pfrom->AddInventoryKnown(_inv);
+                    if (!AlreadyHave(_inv)) pfrom->AskFor(_inv);
                 }
                 AddOrphanTx(tx, pfrom->GetId());
 
@@ -6317,9 +6317,9 @@ class CompareInvMempoolOrder
 {
     CTxMemPool *mp;
 public:
-    CompareInvMempoolOrder(CTxMemPool *mempool)
+    CompareInvMempoolOrder(CTxMemPool *_mempool)
     {
-        mp = mempool;
+        mp = _mempool;
     }
 
     bool operator()(std::set<uint256>::iterator a, std::set<uint256>::iterator b)
diff --git a/src/pubkey.cpp b/src/pubkey.cpp
@@ -264,12 +264,12 @@ void CExtPubKey::Decode(const unsigned char code[BIP32_EXTKEY_SIZE]) {
     pubkey.Set(code+41, code+BIP32_EXTKEY_SIZE);
 }
 
-bool CExtPubKey::Derive(CExtPubKey &out, unsigned int nChild) const {
+bool CExtPubKey::Derive(CExtPubKey &out, unsigned int _nChild) const {
     out.nDepth = nDepth + 1;
     CKeyID id = pubkey.GetID();
     memcpy(&out.vchFingerprint[0], &id, 4);
-    out.nChild = nChild;
-    return pubkey.Derive(out.pubkey, out.chaincode, nChild, chaincode);
+    out.nChild = _nChild;
+    return pubkey.Derive(out.pubkey, out.chaincode, _nChild, chaincode);
 }
 
 /* static */ bool CPubKey::CheckLowS(const std::vector<unsigned char>& vchSig) {
diff --git a/src/pubkey.h b/src/pubkey.h
@@ -88,9 +88,9 @@ class CPubKey
     }
 
     //! Construct a public key from a byte vector.
-    CPubKey(const std::vector<unsigned char>& vch)
+    CPubKey(const std::vector<unsigned char>& _vch)
     {
-        Set(vch.begin(), vch.end());
+        Set(_vch.begin(), _vch.end());
     }
 
     //! Simple read-only vector-like interface to the pubkey data.
diff --git a/src/reverselock.h b/src/reverselock.h
@@ -13,9 +13,9 @@ class reverse_lock
 {
 public:
 
-    explicit reverse_lock(Lock& lock) : lock(lock) {
-        lock.unlock();
-        lock.swap(templock);
+    explicit reverse_lock(Lock& _lock) : lock(_lock) {
+        _lock.unlock();
+        _lock.swap(templock);
     }
 
     ~reverse_lock() {
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
@@ -497,10 +497,10 @@ UniValue getmempoolancestors(const UniValue& params, bool fHelp)
         UniValue o(UniValue::VOBJ);
         BOOST_FOREACH(CTxMemPool::txiter ancestorIt, setAncestors) {
             const CTxMemPoolEntry &e = *ancestorIt;
-            const uint256& hash = e.GetTx().GetHash();
+            const uint256& _hash = e.GetTx().GetHash();
             UniValue info(UniValue::VOBJ);
             entryToJSON(info, e);
-            o.push_back(Pair(hash.ToString(), info));
+            o.push_back(Pair(_hash.ToString(), info));
         }
         return o;
     }
@@ -561,10 +561,10 @@ UniValue getmempooldescendants(const UniValue& params, bool fHelp)
         UniValue o(UniValue::VOBJ);
         BOOST_FOREACH(CTxMemPool::txiter descendantIt, setDescendants) {
             const CTxMemPoolEntry &e = *descendantIt;
-            const uint256& hash = e.GetTx().GetHash();
+            const uint256& _hash = e.GetTx().GetHash();
             UniValue info(UniValue::VOBJ);
             entryToJSON(info, e);
-            o.push_back(Pair(hash.ToString(), info));
+            o.push_back(Pair(_hash.ToString(), info));
         }
         return o;
     }
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
@@ -607,8 +607,8 @@ UniValue getblocktemplate(const UniValue& params, bool fHelp)
 
     UniValue aRules(UniValue::VARR);
     UniValue vbavailable(UniValue::VOBJ);
-    for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++i) {
-        Consensus::DeploymentPos pos = Consensus::DeploymentPos(i);
+    for (int j = 0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {
+        Consensus::DeploymentPos pos = Consensus::DeploymentPos(j);
         ThresholdState state = VersionBitsState(pindexPrev, consensusParams, pos, versionbitscache);
         switch (state) {
             case THRESHOLD_DEFINED:
diff --git a/src/support/pagelocker.h b/src/support/pagelocker.h
@@ -28,11 +28,11 @@ template <class Locker>
 class LockedPageManagerBase
 {
 public:
-    LockedPageManagerBase(size_t page_size) : page_size(page_size)
+    LockedPageManagerBase(size_t _page_size) : page_size(_page_size)
     {
         // Determine bitmask for extracting page from address
-        assert(!(page_size & (page_size - 1))); // size must be power of two
-        page_mask = ~(page_size - 1);
+        assert(!(_page_size & (_page_size - 1))); // size must be power of two
+        page_mask = ~(_page_size - 1);
     }
 
     ~LockedPageManagerBase()
diff --git a/src/test/crypto_tests.cpp b/src/test/crypto_tests.cpp
@@ -133,13 +133,13 @@ void TestAES128CBC(const std::string &hexkey, const std::string &hexiv, bool pad
     {
         std::vector<unsigned char> sub(i, in.end());
         std::vector<unsigned char> subout(sub.size() + AES_BLOCKSIZE);
-        int size = enc.Encrypt(&sub[0], sub.size(), &subout[0]);
-        if (size != 0)
+        int _size = enc.Encrypt(&sub[0], sub.size(), &subout[0]);
+        if (_size != 0)
         {
-            subout.resize(size);
+            subout.resize(_size);
             std::vector<unsigned char> subdecrypted(subout.size());
-            size = dec.Decrypt(&subout[0], subout.size(), &subdecrypted[0]);
-            subdecrypted.resize(size);
+            _size = dec.Decrypt(&subout[0], subout.size(), &subdecrypted[0]);
+            subdecrypted.resize(_size);
             BOOST_CHECK(decrypted.size() == in.size());
             BOOST_CHECK_MESSAGE(subdecrypted == sub, HexStr(subdecrypted) + std::string(" != ") + HexStr(sub));
         }
@@ -174,13 +174,13 @@ void TestAES256CBC(const std::string &hexkey, const std::string &hexiv, bool pad
     {
         std::vector<unsigned char> sub(i, in.end());
         std::vector<unsigned char> subout(sub.size() + AES_BLOCKSIZE);
-        int size = enc.Encrypt(&sub[0], sub.size(), &subout[0]);
-        if (size != 0)
+        int _size = enc.Encrypt(&sub[0], sub.size(), &subout[0]);
+        if (_size != 0)
         {
-            subout.resize(size);
+            subout.resize(_size);
             std::vector<unsigned char> subdecrypted(subout.size());
-            size = dec.Decrypt(&subout[0], subout.size(), &subdecrypted[0]);
-            subdecrypted.resize(size);
+            _size = dec.Decrypt(&subout[0], subout.size(), &subdecrypted[0]);
+            subdecrypted.resize(_size);
             BOOST_CHECK(decrypted.size() == in.size());
             BOOST_CHECK_MESSAGE(subdecrypted == sub, HexStr(subdecrypted) + std::string(" != ") + HexStr(sub));
         }
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
@@ -62,11 +62,11 @@ class CAddrManCorrupted : public CAddrManSerializationMock
     }
 };
 
-CDataStream AddrmanToStream(CAddrManSerializationMock& addrman)
+CDataStream AddrmanToStream(CAddrManSerializationMock& _addrman)
 {
     CDataStream ssPeersIn(SER_DISK, CLIENT_VERSION);
     ssPeersIn << FLATDATA(Params().MessageStart());
-    ssPeersIn << addrman;
+    ssPeersIn << _addrman;
     std::string str = ssPeersIn.str();
     vector<unsigned char> vchData(str.begin(), str.end());
     return CDataStream(vchData, SER_DISK, CLIENT_VERSION);
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
@@ -323,10 +323,10 @@ class TestBuilder
         return *this;
     }
 
-    TestBuilder& Add(const CScript& script)
+    TestBuilder& Add(const CScript& _script)
     {
         DoPush();
-        spendTx.vin[0].scriptSig += script;
+        spendTx.vin[0].scriptSig += _script;
         return *this;
     }
 
@@ -343,8 +343,8 @@ class TestBuilder
         return *this;
     }
 
-    TestBuilder& Push(const CScript& script) {
-         DoPush(std::vector<unsigned char>(script.begin(), script.end()));
+    TestBuilder& Push(const CScript& _script) {
+         DoPush(std::vector<unsigned char>(_script.begin(), _script.end()));
         return *this;
     }
 
diff --git a/src/torcontrol.cpp b/src/torcontrol.cpp
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp

Original file line number	Diff line number	Diff line change
`@@ -280,8 +280,8 @@ void CRollingBloomFilter::insert(const std::vector<unsigned char>& vKey)`
`280`	`280`
`281`	`281`	`void CRollingBloomFilter::insert(const uint256& hash)`
`282`	`282`	`{`
`283`		`- vector<unsigned char> data(hash.begin(), hash.end());`
`284`		`- insert(data);`
	`283`	`+ vector<unsigned char> vData(hash.begin(), hash.end());`
	`284`	`+ insert(vData);`
`285`	`285`	`}`
`286`	`286`
`287`	`287`	`bool CRollingBloomFilter::contains(const std::vector<unsigned char>& vKey) const`
`@@ -300,8 +300,8 @@ bool CRollingBloomFilter::contains(const std::vector<unsigned char>& vKey) const`
`300`	`300`
`301`	`301`	`bool CRollingBloomFilter::contains(const uint256& hash) const`
`302`	`302`	`{`
`303`		`- vector<unsigned char> data(hash.begin(), hash.end());`
`304`		`- return contains(data);`
	`303`	`+ vector<unsigned char> vData(hash.begin(), hash.end());`
	`304`	`+ return contains(vData);`
`305`	`305`	`}`
`306`	`306`
`307`	`307`	`void CRollingBloomFilter::reset()`
Original file line number	Diff line number	Diff line change
`@@ -243,12 +243,12 @@ bool CKey::Derive(CKey& keyChild, ChainCode &ccChild, unsigned int nChild, const`
`243`	`243`	`return ret;`
`244`	`244`	`}`
`245`	`245`
`246`		`-bool CExtKey::Derive(CExtKey &out, unsigned int nChild) const {`
	`246`	`+bool CExtKey::Derive(CExtKey &out, unsigned int _nChild) const {`
`247`	`247`	`out.nDepth = nDepth + 1;`
`248`	`248`	`CKeyID id = key.GetPubKey().GetID();`
`249`	`249`	`memcpy(&out.vchFingerprint[0], &id, 4);`
`250`		`- out.nChild = nChild;`
`251`		`- return key.Derive(out.key, out.chaincode, nChild, chaincode);`
	`250`	`+ out.nChild = _nChild;`
	`251`	`+ return key.Derive(out.key, out.chaincode, _nChild, chaincode);`
`252`	`252`	`}`
`253`	`253`
`254`	`254`	`void CExtKey::SetMaster(const unsigned char *seed, unsigned int nSeedLen) {`
Original file line number	Diff line number	Diff line change
`@@ -1185,9 +1185,9 @@ bool AcceptToMemoryPoolWorker(CTxMemPool& pool, CValidationState& state, const C`
`1185`	`1185`	`bool fReplacementOptOut = true;`
`1186`	`1186`	`if (fEnableReplacement)`
`1187`	`1187`	`{`
`1188`		`- BOOST_FOREACH(const CTxIn &txin, ptxConflicting->vin)`
	`1188`	`+ BOOST_FOREACH(const CTxIn &_txin, ptxConflicting->vin)`
`1189`	`1189`	`{`
`1190`		`- if (txin.nSequence < std::numeric_limits<unsigned int>::max()-1)`
	`1190`	`+ if (_txin.nSequence < std::numeric_limits<unsigned int>::max()-1)`
`1191`	`1191`	`{`
`1192`	`1192`	`fReplacementOptOut = false;`
`1193`	`1193`	`break;`
`@@ -2499,14 +2499,14 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin`
`2499`	`2499`	`if (pindex->GetUndoPos().IsNull() \|\| !pindex->IsValid(BLOCK_VALID_SCRIPTS))`
`2500`	`2500`	`{`
`2501`	`2501`	`if (pindex->GetUndoPos().IsNull()) {`
`2502`		`- CDiskBlockPos pos;`
`2503`		`- if (!FindUndoPos(state, pindex->nFile, pos, ::GetSerializeSize(blockundo, SER_DISK, CLIENT_VERSION) + 40))`
	`2502`	`+ CDiskBlockPos _pos;`
	`2503`	`+ if (!FindUndoPos(state, pindex->nFile, _pos, ::GetSerializeSize(blockundo, SER_DISK, CLIENT_VERSION) + 40))`
`2504`	`2504`	`return error("ConnectBlock(): FindUndoPos failed");`
`2505`		`- if (!UndoWriteToDisk(blockundo, pos, pindex->pprev->GetBlockHash(), chainparams.MessageStart()))`
	`2505`	`+ if (!UndoWriteToDisk(blockundo, _pos, pindex->pprev->GetBlockHash(), chainparams.MessageStart()))`
`2506`	`2506`	`return AbortNode(state, "Failed to write undo data");`
`2507`	`2507`
`2508`	`2508`	`// update nUndoPos in block index`
`2509`		`- pindex->nUndoPos = pos.nPos;`
	`2509`	`+ pindex->nUndoPos = _pos.nPos;`
`2510`	`2510`	`pindex->nStatus \|= BLOCK_HAVE_UNDO;`
`2511`	`2511`	`}`
`2512`	`2512`
`@@ -3819,10 +3819,10 @@ void PruneOneBlockFile(const int fileNumber)`
`3819`	`3819`	`// mapBlocksUnlinked or setBlockIndexCandidates.`
`3820`	`3820`	`std::pair<std::multimap<CBlockIndex, CBlockIndex>::iterator, std::multimap<CBlockIndex, CBlockIndex>::iterator> range = mapBlocksUnlinked.equal_range(pindex->pprev);`
`3821`	`3821`	`while (range.first != range.second) {`
`3822`		`- std::multimap<CBlockIndex , CBlockIndex >::iterator it = range.first;`
	`3822`	`+ std::multimap<CBlockIndex , CBlockIndex >::iterator _it = range.first;`
`3823`	`3823`	`range.first++;`
`3824`		`- if (it->second == pindex) {`
`3825`		`- mapBlocksUnlinked.erase(it);`
	`3824`	`+ if (_it->second == pindex) {`
	`3825`	`+ mapBlocksUnlinked.erase(_it);`
`3826`	`3826`	`}`
`3827`	`3827`	`}`
`3828`	`3828`	`}`
`@@ -5550,9 +5550,9 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,`
`5550`	`5550`	`}`
`5551`	`5551`	`if (!fRejectedParents) {`
`5552`	`5552`	`BOOST_FOREACH(const CTxIn& txin, tx.vin) {`
`5553`		`- CInv inv(MSG_TX, txin.prevout.hash);`
`5554`		`- pfrom->AddInventoryKnown(inv);`
`5555`		`- if (!AlreadyHave(inv)) pfrom->AskFor(inv);`
	`5553`	`+ CInv _inv(MSG_TX, txin.prevout.hash);`
	`5554`	`+ pfrom->AddInventoryKnown(_inv);`
	`5555`	`+ if (!AlreadyHave(_inv)) pfrom->AskFor(_inv);`
`5556`	`5556`	`}`
`5557`	`5557`	`AddOrphanTx(tx, pfrom->GetId());`
`5558`	`5558`
`@@ -6317,9 +6317,9 @@ class CompareInvMempoolOrder`
`6317`	`6317`	`{`
`6318`	`6318`	`CTxMemPool *mp;`
`6319`	`6319`	`public:`
`6320`		`- CompareInvMempoolOrder(CTxMemPool *mempool)`
	`6320`	`+ CompareInvMempoolOrder(CTxMemPool *_mempool)`
`6321`	`6321`	`{`
`6322`		`- mp = mempool;`
	`6322`	`+ mp = _mempool;`
`6323`	`6323`	`}`
`6324`	`6324`
`6325`	`6325`	`bool operator()(std::set<uint256>::iterator a, std::set<uint256>::iterator b)`
Original file line number	Diff line number	Diff line change
`@@ -264,12 +264,12 @@ void CExtPubKey::Decode(const unsigned char code[BIP32_EXTKEY_SIZE]) {`
`264`	`264`	`pubkey.Set(code+41, code+BIP32_EXTKEY_SIZE);`
`265`	`265`	`}`
`266`	`266`
`267`		`-bool CExtPubKey::Derive(CExtPubKey &out, unsigned int nChild) const {`
	`267`	`+bool CExtPubKey::Derive(CExtPubKey &out, unsigned int _nChild) const {`
`268`	`268`	`out.nDepth = nDepth + 1;`
`269`	`269`	`CKeyID id = pubkey.GetID();`
`270`	`270`	`memcpy(&out.vchFingerprint[0], &id, 4);`
`271`		`- out.nChild = nChild;`
`272`		`- return pubkey.Derive(out.pubkey, out.chaincode, nChild, chaincode);`
	`271`	`+ out.nChild = _nChild;`
	`272`	`+ return pubkey.Derive(out.pubkey, out.chaincode, _nChild, chaincode);`
`273`	`273`	`}`
`274`	`274`
`275`	`275`	`/* static */ bool CPubKey::CheckLowS(const std::vector<unsigned char>& vchSig) {`
Original file line number	Diff line number	Diff line change
`@@ -88,9 +88,9 @@ class CPubKey`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`//! Construct a public key from a byte vector.`
`91`		`- CPubKey(const std::vector<unsigned char>& vch)`
	`91`	`+ CPubKey(const std::vector<unsigned char>& _vch)`
`92`	`92`	`{`
`93`		`- Set(vch.begin(), vch.end());`
	`93`	`+ Set(_vch.begin(), _vch.end());`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`//! Simple read-only vector-like interface to the pubkey data.`
Original file line number	Diff line number	Diff line change
`@@ -13,9 +13,9 @@ class reverse_lock`
`13`	`13`	`{`
`14`	`14`	`public:`
`15`	`15`
`16`		`- explicit reverse_lock(Lock& lock) : lock(lock) {`
`17`		`- lock.unlock();`
`18`		`- lock.swap(templock);`
	`16`	`+ explicit reverse_lock(Lock& _lock) : lock(_lock) {`
	`17`	`+ _lock.unlock();`
	`18`	`+ _lock.swap(templock);`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`~reverse_lock() {`
Original file line number	Diff line number	Diff line change
`@@ -28,11 +28,11 @@ template <class Locker>`
`28`	`28`	`class LockedPageManagerBase`
`29`	`29`	`{`
`30`	`30`	`public:`
`31`		`- LockedPageManagerBase(size_t page_size) : page_size(page_size)`
	`31`	`+ LockedPageManagerBase(size_t _page_size) : page_size(_page_size)`
`32`	`32`	`{`
`33`	`33`	`// Determine bitmask for extracting page from address`
`34`		`- assert(!(page_size & (page_size - 1))); // size must be power of two`
`35`		`- page_mask = ~(page_size - 1);`
	`34`	`+ assert(!(_page_size & (_page_size - 1))); // size must be power of two`
	`35`	`+ page_mask = ~(_page_size - 1);`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`~LockedPageManagerBase()`