sw: prefix members of BigPtrArray

Change-Id: I87a91fad09616add823e7e556597419d02e43c6c
Reviewed-on: https://gerrit.libreoffice.org/31311
Reviewed-by: Miklos Vajna <vmiklos@collabora.co.uk>
Tested-by: Jenkins <ci@libreoffice.org>

3 files changed, 82 insertions, 82 deletions

diff --git a/sw/inc/bparr.hxx b/sw/inc/bparr.hxx
index 9ec8c91869b6..53a3f184bc36 100644
--- a/sw/inc/bparr.hxx
+++ b/sw/inc/bparr.hxx
@@ -61,12 +61,12 @@ struct BlockInfo {                  // block info:
 class SW_DLLPUBLIC BigPtrArray
 {
 protected:
-    BlockInfo**     ppInf;              // block info
-    sal_uLong       nSize;              ///< number of elements
-    sal_uInt16      nMaxBlock;          ///< current max. number of blocks
-    sal_uInt16      nBlock;             ///< number of blocks
+    BlockInfo**     m_ppInf;              // block info
+    sal_uLong       m_nSize;              ///< number of elements
+    sal_uInt16      m_nMaxBlock;          ///< current max. number of blocks
+    sal_uInt16      m_nBlock;             ///< number of blocks
     mutable
-        sal_uInt16  nCur;               ///< last used block
+        sal_uInt16  m_nCur;               ///< last used block
 
     sal_uInt16  Index2Block( sal_uLong ) const; ///< block search
     BlockInfo*  InsBlock( sal_uInt16 );         ///< insert block
@@ -80,7 +80,7 @@ public:
     BigPtrArray();
     ~BigPtrArray();
 
-    sal_uLong Count() const { return nSize; }
+    sal_uLong Count() const { return m_nSize; }
 
     void Insert( const ElementPtr& r, sal_uLong pos );
     void Remove( sal_uLong pos, sal_uLong n = 1 );
diff --git a/sw/source/core/bastyp/bparr.cxx b/sw/source/core/bastyp/bparr.cxx
index f5e3166445ab..f4cd90206de6 100644
--- a/sw/source/core/bastyp/bparr.cxx
+++ b/sw/source/core/bastyp/bparr.cxx
@@ -47,24 +47,24 @@ void CheckIdx( BlockInfo** ppInf, sal_uInt16 nBlock, sal_uLong nSize, sal_uInt16
 
 BigPtrArray::BigPtrArray()
 {
-    nBlock = nCur = 0;
-    nSize = 0;
-    nMaxBlock = nBlockGrowSize;
-    ppInf = new BlockInfo* [ nMaxBlock ];
+    m_nBlock = m_nCur = 0;
+    m_nSize = 0;
+    m_nMaxBlock = nBlockGrowSize;
+    m_ppInf = new BlockInfo* [ m_nMaxBlock ];
 }
 
 BigPtrArray::~BigPtrArray()
 {
-    if( nBlock )
+    if( m_nBlock )
     {
-        BlockInfo** pp = ppInf;
-        for( sal_uInt16 n = 0; n < nBlock; ++n, ++pp )
+        BlockInfo** pp = m_ppInf;
+        for( sal_uInt16 n = 0; n < m_nBlock; ++n, ++pp )
         {
             delete[] (*pp)->pData;
             delete    *pp;
         }
     }
-    delete[] ppInf;
+    delete[] m_ppInf;
 }
 
 // Also moving is done simply here. Optimization is useless because of the
@@ -74,7 +74,7 @@ void BigPtrArray::Move( sal_uLong from, sal_uLong to )
     if (from != to)
     {
         sal_uInt16 cur = Index2Block( from );
-        BlockInfo* p = ppInf[ cur ];
+        BlockInfo* p = m_ppInf[ cur ];
         ElementPtr pElem = p->pData[ from - p->nStart ];
         Insert( pElem, to ); // insert first, then delete!
         Remove( ( to < from ) ? ( from + 1 ) : from );
@@ -83,9 +83,9 @@ void BigPtrArray::Move( sal_uLong from, sal_uLong to )
 
 ElementPtr BigPtrArray::operator[]( sal_uLong idx ) const
 {
-    assert(idx < nSize); // operator[]: Index out of bounds
-    nCur = Index2Block( idx );
-    BlockInfo* p = ppInf[ nCur ];
+    assert(idx < m_nSize); // operator[]: Index out of bounds
+    m_nCur = Index2Block( idx );
+    BlockInfo* p = m_ppInf[ m_nCur ];
     return p->pData[ idx - p->nStart ];
 }
 
@@ -93,36 +93,36 @@ ElementPtr BigPtrArray::operator[]( sal_uLong idx ) const
 sal_uInt16 BigPtrArray::Index2Block( sal_uLong pos ) const
 {
     // last used block?
-    BlockInfo* p = ppInf[ nCur ];
+    BlockInfo* p = m_ppInf[ m_nCur ];
     if( p->nStart <= pos && p->nEnd >= pos )
-        return nCur;
+        return m_nCur;
     // Index = 0?
     if( !pos )
         return 0;
 
     // following one?
-    if( nCur < ( nBlock - 1 ) )
+    if( m_nCur < ( m_nBlock - 1 ) )
     {
-        p = ppInf[ nCur+1 ];
+        p = m_ppInf[ m_nCur+1 ];
         if( p->nStart <= pos && p->nEnd >= pos )
-            return nCur+1;
+            return m_nCur+1;
     }
     // previous one?
-    else if( pos < p->nStart && nCur > 0 )
+    else if( pos < p->nStart && m_nCur > 0 )
     {
-        p = ppInf[ nCur-1 ];
+        p = m_ppInf[ m_nCur-1 ];
         if( p->nStart <= pos && p->nEnd >= pos )
-            return nCur-1;
+            return m_nCur-1;
     }
 
     // binary search: always successful
-    sal_uInt16 lower = 0, upper = nBlock - 1;
+    sal_uInt16 lower = 0, upper = m_nBlock - 1;
     sal_uInt16 cur = 0;
     for(;;)
     {
         sal_uInt16 n = lower + ( upper - lower ) / 2;
         cur = ( n == cur ) ? n+1 : n;
-        p = ppInf[ cur ];
+        p = m_ppInf[ cur ];
         if( p->nStart <= pos && p->nEnd >= pos )
             return cur;
 
@@ -139,9 +139,9 @@ sal_uInt16 BigPtrArray::Index2Block( sal_uLong pos ) const
 */
 void BigPtrArray::UpdIndex( sal_uInt16 pos )
 {
-    BlockInfo** pp = ppInf + pos;
+    BlockInfo** pp = m_ppInf + pos;
     sal_uLong idx = (*pp)->nEnd + 1;
-    while( ++pos < nBlock )
+    while( ++pos < m_nBlock )
     {
         BlockInfo* p = *++pp;
         p->nStart = idx;
@@ -158,26 +158,26 @@ void BigPtrArray::UpdIndex( sal_uInt16 pos )
 */
 BlockInfo* BigPtrArray::InsBlock( sal_uInt16 pos )
 {
-    if( nBlock == nMaxBlock )
+    if( m_nBlock == m_nMaxBlock )
     {
         // than extend the array first
-        BlockInfo** ppNew = new BlockInfo* [ nMaxBlock + nBlockGrowSize ];
-        memcpy( ppNew, ppInf, nMaxBlock * sizeof( BlockInfo* ));
-        delete[] ppInf;
-        nMaxBlock += nBlockGrowSize;
-        ppInf = ppNew;
+        BlockInfo** ppNew = new BlockInfo* [ m_nMaxBlock + nBlockGrowSize ];
+        memcpy( ppNew, m_ppInf, m_nMaxBlock * sizeof( BlockInfo* ));
+        delete[] m_ppInf;
+        m_nMaxBlock += nBlockGrowSize;
+        m_ppInf = ppNew;
     }
-    if( pos != nBlock )
+    if( pos != m_nBlock )
     {
-        memmove( ppInf + pos+1, ppInf + pos,
-                 ( nBlock - pos ) * sizeof( BlockInfo* ));
+        memmove( m_ppInf + pos+1, m_ppInf + pos,
+                 ( m_nBlock - pos ) * sizeof( BlockInfo* ));
     }
-    ++nBlock;
+    ++m_nBlock;
     BlockInfo* p = new BlockInfo;
-    ppInf[ pos ] = p;
+    m_ppInf[ pos ] = p;
 
     if( pos )
-        p->nStart = p->nEnd = ppInf[ pos-1 ]->nEnd + 1;
+        p->nStart = p->nEnd = m_ppInf[ pos-1 ]->nEnd + 1;
     else
         p->nStart = p->nEnd = 0;
 
@@ -190,16 +190,16 @@ BlockInfo* BigPtrArray::InsBlock( sal_uInt16 pos )
 
 void BigPtrArray::BlockDel( sal_uInt16 nDel )
 {
-    nBlock = nBlock - nDel;
-    if( nMaxBlock - nBlock > nBlockGrowSize )
+    m_nBlock = m_nBlock - nDel;
+    if( m_nMaxBlock - m_nBlock > nBlockGrowSize )
     {
         // than shrink array
-        nDel = (( nBlock / nBlockGrowSize ) + 1 ) * nBlockGrowSize;
+        nDel = (( m_nBlock / nBlockGrowSize ) + 1 ) * nBlockGrowSize;
         BlockInfo** ppNew = new BlockInfo* [ nDel ];
-        memcpy( ppNew, ppInf, nBlock * sizeof( BlockInfo* ));
-        delete[] ppInf;
-        ppInf = ppNew;
-        nMaxBlock = nDel;
+        memcpy( ppNew, m_ppInf, m_nBlock * sizeof( BlockInfo* ));
+        delete[] m_ppInf;
+        m_ppInf = ppNew;
+        m_nMaxBlock = nDel;
     }
 }
 
@@ -209,16 +209,16 @@ void BigPtrArray::Insert( const ElementPtr& rElem, sal_uLong pos )
 
     BlockInfo* p;
     sal_uInt16 cur;
-    if( !nSize )
+    if( !m_nSize )
     {
         // special case: insert first element
         p = InsBlock( cur = 0 );
     }
-    else if( pos == nSize )
+    else if( pos == m_nSize )
     {
         // special case: insert at end
-        cur = nBlock - 1;
-        p = ppInf[ cur ];
+        cur = m_nBlock - 1;
+        p = m_ppInf[ cur ];
         if( p->nElem == MAXENTRY )
             // the last block is full, create a new one
             p = InsBlock( ++cur );
@@ -227,16 +227,16 @@ void BigPtrArray::Insert( const ElementPtr& rElem, sal_uLong pos )
     {
         // standard case:
         cur = Index2Block( pos );
-        p = ppInf[ cur ];
+        p = m_ppInf[ cur ];
     }
 
     if( p->nElem == MAXENTRY )
     {
         // does the last entry fit into the next block?
         BlockInfo* q;
-        if( cur < ( nBlock - 1 ) && ppInf[ cur+1 ]->nElem < MAXENTRY )
+        if( cur < ( m_nBlock - 1 ) && m_ppInf[ cur+1 ]->nElem < MAXENTRY )
         {
-            q = ppInf[ cur+1 ];
+            q = m_ppInf[ cur+1 ];
             if( q->nElem )
             {
                 int nCount = q->nElem;
@@ -253,7 +253,7 @@ void BigPtrArray::Insert( const ElementPtr& rElem, sal_uLong pos )
             // If it does not fit, then insert a new block. But if there is more
             // than 50% space in the array then compress first.
             if( /*nBlock == nMaxBlock &&*/
-                nBlock > ( nSize / ( MAXENTRY / 2 ) ) &&
+                m_nBlock > ( m_nSize / ( MAXENTRY / 2 ) ) &&
                 cur >= Compress() )
             {
                 // Something was moved before the current position and all
@@ -294,9 +294,9 @@ void BigPtrArray::Insert( const ElementPtr& rElem, sal_uLong pos )
     p->pData[ pos ] = rElem;
     p->nEnd++;
     p->nElem++;
-    nSize++;
-    if( cur != ( nBlock - 1 ) ) UpdIndex( cur );
-    nCur = cur;
+    m_nSize++;
+    if( cur != ( m_nBlock - 1 ) ) UpdIndex( cur );
+    m_nCur = cur;
 
     CHECKIDX( ppInf, nBlock, nSize, nCur );
 }
@@ -309,7 +309,7 @@ void BigPtrArray::Remove( sal_uLong pos, sal_uLong n )
     sal_uInt16 cur = Index2Block( pos ); // current block number
     sal_uInt16 nBlk1 = cur;              // 1st treated block
     sal_uInt16 nBlk1del = USHRT_MAX;     // 1st deleted block
-    BlockInfo* p = ppInf[ cur ];
+    BlockInfo* p = m_ppInf[ cur ];
     pos -= p->nStart;
 
     sal_uLong nElem = n;
@@ -344,7 +344,7 @@ void BigPtrArray::Remove( sal_uLong pos, sal_uLong n )
         nElem -= nel;
         if( !nElem )
             break;
-        p = ppInf[ ++cur ];
+        p = m_ppInf[ ++cur ];
         pos = 0;
     }
 
@@ -352,17 +352,17 @@ void BigPtrArray::Remove( sal_uLong pos, sal_uLong n )
     if( nBlkdel )
     {
         for( sal_uInt16 i = nBlk1del; i < ( nBlk1del + nBlkdel ); i++ )
-            delete ppInf[ i ];
+            delete m_ppInf[ i ];
 
-        if( ( nBlk1del + nBlkdel ) < nBlock )
+        if( ( nBlk1del + nBlkdel ) < m_nBlock )
         {
-            memmove( ppInf + nBlk1del, ppInf + nBlk1del + nBlkdel,
-                     ( nBlock - nBlkdel - nBlk1del ) * sizeof( BlockInfo* ) );
+            memmove( m_ppInf + nBlk1del, m_ppInf + nBlk1del + nBlkdel,
+                     ( m_nBlock - nBlkdel - nBlk1del ) * sizeof( BlockInfo* ) );
 
             // UpdateIdx updates the successor thus start before first elem
             if( !nBlk1 )
             {
-                p = ppInf[ 0 ];
+                p = m_ppInf[ 0 ];
                 p->nStart = 0;
                 p->nEnd = p->nElem-1;
             }
@@ -374,13 +374,13 @@ void BigPtrArray::Remove( sal_uLong pos, sal_uLong n )
         BlockDel( nBlkdel ); // blocks were deleted
     }
 
-    nSize -= n;
-    if( nBlk1 != ( nBlock - 1 ) && nSize )
+    m_nSize -= n;
+    if( nBlk1 != ( m_nBlock - 1 ) && m_nSize )
         UpdIndex( nBlk1 );
-    nCur = nBlk1;
+    m_nCur = nBlk1;
 
     // call Compress() if there is more than 50% space in the array
-    if( nBlock > ( nSize / ( MAXENTRY / 2 ) ) )
+    if( m_nBlock > ( m_nSize / ( MAXENTRY / 2 ) ) )
         Compress();
 
     CHECKIDX( ppInf, nBlock, nSize, nCur );
@@ -388,9 +388,9 @@ void BigPtrArray::Remove( sal_uLong pos, sal_uLong n )
 
 void BigPtrArray::Replace( sal_uLong idx, const ElementPtr& rElem)
 {
-    assert(idx < nSize); // Index out of bounds
-    nCur = Index2Block( idx );
-    BlockInfo* p = ppInf[ nCur ];
+    assert(idx < m_nSize); // Index out of bounds
+    m_nCur = Index2Block( idx );
+    BlockInfo* p = m_ppInf[ m_nCur ];
     rElem->nOffset = sal_uInt16(idx - p->nStart);
     rElem->pBlock = p;
     p->pData[ idx - p->nStart ] = rElem;
@@ -404,7 +404,7 @@ sal_uInt16 BigPtrArray::Compress()
     // Iterate over InfoBlock array from beginning to end. If there is a deleted
     // block in between so move all following ones accordingly. The pointer <pp>
     // represents the "old" and <qq> the "new" array.
-    BlockInfo** pp = ppInf, **qq = pp;
+    BlockInfo** pp = m_ppInf, **qq = pp;
     BlockInfo* p;
     BlockInfo* pLast(nullptr);                 // last empty block
     sal_uInt16 nLast = 0;                // missing elements
@@ -414,7 +414,7 @@ sal_uInt16 BigPtrArray::Compress()
     // convert fill percentage into number of remaining elements
     short nMax = MAXENTRY - (long) MAXENTRY * COMPRESSLVL / 100;
 
-    for( sal_uInt16 cur = 0; cur < nBlock; ++cur )
+    for( sal_uInt16 cur = 0; cur < m_nBlock; ++cur )
     {
         p = *pp++;
         sal_uInt16 n = p->nElem;
@@ -490,12 +490,12 @@ sal_uInt16 BigPtrArray::Compress()
         BlockDel( nBlkdel );
 
     // and re-index
-    p = ppInf[ 0 ];
+    p = m_ppInf[ 0 ];
     p->nEnd = p->nElem - 1;
     UpdIndex( 0 );
 
-    if( nCur >= nFirstChgPos )
-        nCur = 0;
+    if( m_nCur >= nFirstChgPos )
+        m_nCur = 0;
 
     CHECKIDX( ppInf, nBlock, nSize, nCur );
 
diff --git a/sw/source/core/docnode/nodes.cxx b/sw/source/core/docnode/nodes.cxx
index 1e0b282cfe43..aec2552fe3e4 100644
--- a/sw/source/core/docnode/nodes.cxx
+++ b/sw/source/core/docnode/nodes.cxx
@@ -2179,13 +2179,13 @@ SwNode* SwNodes::FindPrvNxtFrameNode( SwNodeIndex& rFrameIdx,
 void SwNodes::ForEach( sal_uLong nStart, sal_uLong nEnd,
                        FnForEach_SwNodes fn, void* pArgs )
 {
-    if( nEnd > nSize )
-        nEnd = nSize;
+    if( nEnd > m_nSize )
+        nEnd = m_nSize;
 
     if( nStart < nEnd )
     {
         sal_uInt16 cur = Index2Block( nStart );
-        BlockInfo** pp = ppInf + cur;
+        BlockInfo** pp = m_ppInf + cur;
         BlockInfo* p = *pp;
         sal_uInt16 nElem = sal_uInt16( nStart - p->nStart );
         ElementPtr* pElem = p->pData + nElem;