Avoid reserved identifiers

Change-Id: I782784f34975d708fdf179d098ce6654aad7a976

34 files changed, 371 insertions, 371 deletions

diff --git a/sc/inc/fstalgorithm.hxx b/sc/inc/fstalgorithm.hxx
index aae070c97980..73a4c5c3d64a 100644
--- a/sc/inc/fstalgorithm.hxx
+++ b/sc/inc/fstalgorithm.hxx
@@ -15,28 +15,28 @@
 
 namespace sc {
 
-template<typename _Key, typename _Span>
+template<typename Key, typename Span>
 void buildSpan(
-    std::vector<_Span>& rSpans,
-    typename mdds::flat_segment_tree<_Key,bool>::const_iterator it,
-    typename mdds::flat_segment_tree<_Key,bool>::const_iterator itEnd, const _Key* pStart )
+    std::vector<Span>& rSpans,
+    typename mdds::flat_segment_tree<Key,bool>::const_iterator it,
+    typename mdds::flat_segment_tree<Key,bool>::const_iterator itEnd, const Key* pStart )
 {
-    _Key nLastPos = it->first;
+    Key nLastPos = it->first;
     bool bLastVal = it->second;
     for (++it; it != itEnd; ++it)
     {
-        _Key nThisPos = it->first;
+        Key nThisPos = it->first;
         bool bThisVal = it->second;
 
         if (bLastVal)
         {
-            _Key nIndex1 = nLastPos;
-            _Key nIndex2 = nThisPos-1;
+            Key nIndex1 = nLastPos;
+            Key nIndex2 = nThisPos-1;
 
             if (!pStart || *pStart < nIndex1)
-                rSpans.push_back(_Span(nIndex1, nIndex2));
+                rSpans.push_back(Span(nIndex1, nIndex2));
             else if (*pStart <= nIndex2)
-                rSpans.push_back(_Span(*pStart, nIndex2));
+                rSpans.push_back(Span(*pStart, nIndex2));
         }
 
         nLastPos = nThisPos;
@@ -44,28 +44,28 @@ void buildSpan(
     }
 }
 
-template<typename _Key, typename _Val, typename _Span>
+template<typename Key, typename Val, typename Span>
 void buildSpanWithValue(
-    std::vector<_Span>& rSpans,
-    typename mdds::flat_segment_tree<_Key,_Val>::const_iterator it,
-    typename mdds::flat_segment_tree<_Key,_Val>::const_iterator itEnd, const _Key* pStart )
+    std::vector<Span>& rSpans,
+    typename mdds::flat_segment_tree<Key,Val>::const_iterator it,
+    typename mdds::flat_segment_tree<Key,Val>::const_iterator itEnd, const Key* pStart )
 {
-    _Key nLastPos = it->first;
-    _Val nLastVal = it->second;
+    Key nLastPos = it->first;
+    Val nLastVal = it->second;
     for (++it; it != itEnd; ++it)
     {
-        _Key nThisPos = it->first;
-        _Val nThisVal = it->second;
+        Key nThisPos = it->first;
+        Val nThisVal = it->second;
 
         if (nLastVal)
         {
-            _Key nIndex1 = nLastPos;
-            _Key nIndex2 = nThisPos-1;
+            Key nIndex1 = nLastPos;
+            Key nIndex2 = nThisPos-1;
 
             if (!pStart || *pStart < nIndex1)
-                rSpans.push_back(_Span(nIndex1, nIndex2, nLastVal));
+                rSpans.push_back(Span(nIndex1, nIndex2, nLastVal));
             else if (*pStart <= nIndex2)
-                rSpans.push_back(_Span(*pStart, nIndex2, nLastVal));
+                rSpans.push_back(Span(*pStart, nIndex2, nLastVal));
         }
 
         nLastPos = nThisPos;
@@ -78,15 +78,15 @@ void buildSpanWithValue(
  * an array of ranges that corresponds with the segments that have a 'true'
  * value.
  */
-template<typename _Key, typename _Span>
-std::vector<_Span> toSpanArray( const mdds::flat_segment_tree<_Key,bool>& rTree )
+template<typename Key, typename Span>
+std::vector<Span> toSpanArray( const mdds::flat_segment_tree<Key,bool>& rTree )
 {
-    typedef mdds::flat_segment_tree<_Key,bool> FstType;
+    typedef mdds::flat_segment_tree<Key,bool> FstType;
 
-    std::vector<_Span> aSpans;
+    std::vector<Span> aSpans;
 
     typename FstType::const_iterator it = rTree.begin(), itEnd = rTree.end();
-    buildSpan<_Key,_Span>(aSpans, it, itEnd, nullptr);
+    buildSpan<Key,Span>(aSpans, it, itEnd, nullptr);
     return aSpans;
 }
 
@@ -97,24 +97,24 @@ std::vector<_Span> toSpanArray( const mdds::flat_segment_tree<_Key,bool>& rTree
  * The span type must support a constructor that takes a start key, an end
  * key and a value in this order.
  */
-template<typename _Key, typename _Val, typename _Span>
-std::vector<_Span> toSpanArrayWithValue( const mdds::flat_segment_tree<_Key,_Val>& rTree )
+template<typename Key, typename Val, typename Span>
+std::vector<Span> toSpanArrayWithValue( const mdds::flat_segment_tree<Key,Val>& rTree )
 {
-    typedef mdds::flat_segment_tree<_Key,_Val> FstType;
+    typedef mdds::flat_segment_tree<Key,Val> FstType;
 
-    std::vector<_Span> aSpans;
+    std::vector<Span> aSpans;
 
     typename FstType::const_iterator it = rTree.begin(), itEnd = rTree.end();
-    buildSpanWithValue<_Key,_Val,_Span>(aSpans, it, itEnd, nullptr);
+    buildSpanWithValue<Key,Val,Span>(aSpans, it, itEnd, nullptr);
     return aSpans;
 }
 
-template<typename _Key, typename _Span>
-std::vector<_Span> toSpanArray( const mdds::flat_segment_tree<_Key,bool>& rTree, _Key nStartPos )
+template<typename Key, typename Span>
+std::vector<Span> toSpanArray( const mdds::flat_segment_tree<Key,bool>& rTree, Key nStartPos )
 {
-    typedef mdds::flat_segment_tree<_Key,bool> FstType;
+    typedef mdds::flat_segment_tree<Key,bool> FstType;
 
-    std::vector<_Span> aSpans;
+    std::vector<Span> aSpans;
     if (!rTree.is_tree_valid())
         return aSpans;
 
@@ -127,7 +127,7 @@ std::vector<_Span> toSpanArray( const mdds::flat_segment_tree<_Key,bool>& rTree,
         return aSpans;
 
     typename FstType::const_iterator it = r.first, itEnd = rTree.end();
-    buildSpan<_Key,_Span>(aSpans, it, itEnd, &nStartPos);
+    buildSpan<Key,Span>(aSpans, it, itEnd, &nStartPos);
     return aSpans;
 }
 
diff --git a/sc/inc/matrixoperators.hxx b/sc/inc/matrixoperators.hxx
index f3e5facf93c9..25ecf63331f6 100644
--- a/sc/inc/matrixoperators.hxx
+++ b/sc/inc/matrixoperators.hxx
@@ -17,11 +17,11 @@ namespace op {
 
 
 template<typename T>
-struct _Op
+struct Op_
 {
     const double mInitVal;
     const T maOp;
-    _Op(double InitVal, T aOp):
+    Op_(double InitVal, T aOp):
         mInitVal(InitVal), maOp(aOp)
     {
     }
@@ -31,7 +31,7 @@ struct _Op
     }
 };
 
-using Op = _Op<std::function<void(double&, double)>>;
+using Op = Op_<std::function<void(double&, double)>>;
 
 struct Sum
 {
diff --git a/sc/inc/mtvcellfunc.hxx b/sc/inc/mtvcellfunc.hxx
index d0fd9a1cd734..db72fd4a3278 100644
--- a/sc/inc/mtvcellfunc.hxx
+++ b/sc/inc/mtvcellfunc.hxx
@@ -15,156 +15,156 @@
 
 namespace sc {
 
-template<typename _Func>
-void ProcessFormula(CellStoreType& rStore, _Func& rFunc)
+template<typename Func>
+void ProcessFormula(CellStoreType& rStore, Func& rFunc)
 {
     FuncElseNoOp<size_t> aElse;
-    ProcessElements1<CellStoreType, formula_block, _Func, FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
+    ProcessElements1<CellStoreType, formula_block, Func, FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
 }
 
-template<typename _FuncElem>
+template<typename FuncElem>
 typename CellStoreType::iterator
 ProcessFormula(
-    const CellStoreType::iterator& it, CellStoreType& rStore, SCROW nRow1, SCROW nRow2, _FuncElem& rFuncElem)
+    const CellStoreType::iterator& it, CellStoreType& rStore, SCROW nRow1, SCROW nRow2, FuncElem& rFuncElem)
 {
     FuncElseNoOp<size_t> aElse;
     return ProcessElements1<
-        CellStoreType, formula_block, _FuncElem, FuncElseNoOp<size_t> >(it, rStore, nRow1, nRow2, rFuncElem, aElse);
+        CellStoreType, formula_block, FuncElem, FuncElseNoOp<size_t> >(it, rStore, nRow1, nRow2, rFuncElem, aElse);
 }
 
-template<typename _FuncElem, typename _FuncElse>
+template<typename FuncElem, typename FuncElse>
 typename CellStoreType::iterator
 ProcessFormula(
-    const CellStoreType::iterator& it, CellStoreType& rStore, SCROW nRow1, SCROW nRow2, _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+    const CellStoreType::iterator& it, CellStoreType& rStore, SCROW nRow1, SCROW nRow2, FuncElem& rFuncElem, FuncElse& rFuncElse)
 {
     return ProcessElements1<
-        CellStoreType, formula_block, _FuncElem, _FuncElse>(it, rStore, nRow1, nRow2, rFuncElem, rFuncElse);
+        CellStoreType, formula_block, FuncElem, FuncElse>(it, rStore, nRow1, nRow2, rFuncElem, rFuncElse);
 }
 
-template<typename _Func>
+template<typename Func>
 CellStoreType::iterator
-ProcessEditText(const CellStoreType::iterator& itPos, CellStoreType& rStore, SCROW nRow1, SCROW nRow2, _Func& rFunc)
+ProcessEditText(const CellStoreType::iterator& itPos, CellStoreType& rStore, SCROW nRow1, SCROW nRow2, Func& rFunc)
 {
     FuncElseNoOp<size_t> aElse;
-    return ProcessElements1<CellStoreType, edittext_block, _Func, FuncElseNoOp<size_t> >(
+    return ProcessElements1<CellStoreType, edittext_block, Func, FuncElseNoOp<size_t> >(
         itPos, rStore, nRow1, nRow2, rFunc, aElse);
 }
 
-template<typename _Func>
+template<typename Func>
 void ParseFormula(
-    const CellStoreType& rStore, _Func& rFunc)
+    const CellStoreType& rStore, Func& rFunc)
 {
     FuncElseNoOp<size_t> aElse;
-    ParseElements1<CellStoreType, formula_block, _Func, FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
+    ParseElements1<CellStoreType, formula_block, Func, FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
 }
 
-template<typename _Func>
+template<typename Func>
 typename CellStoreType::const_iterator
 ParseFormula(
     const CellStoreType::const_iterator& itPos, const CellStoreType& rStore,
-    SCROW nStart, SCROW nEnd, _Func& rFunc)
+    SCROW nStart, SCROW nEnd, Func& rFunc)
 {
     FuncElseNoOp<size_t> aElse;
-    return ParseElements1<CellStoreType, formula_block, _Func, FuncElseNoOp<size_t> >(
+    return ParseElements1<CellStoreType, formula_block, Func, FuncElseNoOp<size_t> >(
         itPos, rStore, nStart, nEnd, rFunc, aElse);
 }
 
-template<typename _FuncElem, typename _FuncElse>
+template<typename FuncElem, typename FuncElse>
 typename CellStoreType::const_iterator
 ParseAll(
     const typename CellStoreType::const_iterator& itPos, const CellStoreType& rCells,
-    SCROW nRow1, SCROW nRow2, _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+    SCROW nRow1, SCROW nRow2, FuncElem& rFuncElem, FuncElse& rFuncElse)
 {
     return ParseElements4<CellStoreType,
         numeric_block, string_block, edittext_block, formula_block,
-        _FuncElem, _FuncElse>(
+        FuncElem, FuncElse>(
             itPos, rCells, nRow1, nRow2, rFuncElem, rFuncElse);
 }
 
-template<typename _Func>
+template<typename Func>
 typename CellStoreType::const_iterator
 ParseAllNonEmpty(
     const typename CellStoreType::const_iterator& itPos, const CellStoreType& rCells,
-    SCROW nRow1, SCROW nRow2, _Func& rFunc)
+    SCROW nRow1, SCROW nRow2, Func& rFunc)
 {
     FuncElseNoOp<size_t> aElse;
     return ParseElements4<CellStoreType,
         numeric_block, string_block, edittext_block, formula_block,
-        _Func, FuncElseNoOp<size_t> >(
+        Func, FuncElseNoOp<size_t> >(
             itPos, rCells, nRow1, nRow2, rFunc, aElse);
 }
 
-template<typename _Func>
+template<typename Func>
 typename CellStoreType::const_iterator
 ParseFormulaNumeric(
     const CellStoreType::const_iterator& itPos, const CellStoreType& rCells,
-    SCROW nRow1, SCROW nRow2, _Func& rFunc)
+    SCROW nRow1, SCROW nRow2, Func& rFunc)
 {
     FuncElseNoOp<size_t> aElse;
     return ParseElements2<CellStoreType,
-        numeric_block, formula_block, _Func, FuncElseNoOp<size_t> >(
+        numeric_block, formula_block, Func, FuncElseNoOp<size_t> >(
             itPos, rCells, nRow1, nRow2, rFunc, aElse);
 }
 
-template<typename _Func>
-void ProcessFormulaEditText(CellStoreType& rStore, _Func& rFunc)
+template<typename Func>
+void ProcessFormulaEditText(CellStoreType& rStore, Func& rFunc)
 {
     FuncElseNoOp<size_t> aElse;
-    ProcessElements2<CellStoreType, edittext_block, formula_block, _Func, FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
+    ProcessElements2<CellStoreType, edittext_block, formula_block, Func, FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
 }
 
-template<typename _Func>
+template<typename Func>
 std::pair<CellStoreType::const_iterator, size_t>
-FindFormula(const CellStoreType& rStore, SCROW nRow1, SCROW nRow2, _Func& rFunc)
+FindFormula(const CellStoreType& rStore, SCROW nRow1, SCROW nRow2, Func& rFunc)
 {
     typedef std::pair<size_t,bool> ElseRetType;
     FuncElseNoOp<size_t, ElseRetType> aElse;
-    return FindElement1<CellStoreType, formula_block, _Func, FuncElseNoOp<size_t, ElseRetType> >(rStore, nRow1, nRow2, rFunc, aElse);
+    return FindElement1<CellStoreType, formula_block, Func, FuncElseNoOp<size_t, ElseRetType> >(rStore, nRow1, nRow2, rFunc, aElse);
 }
 
-template<typename _Func>
+template<typename Func>
 std::pair<CellStoreType::const_iterator, size_t>
-FindFormulaEditText(const CellStoreType& rStore, SCROW nRow1, SCROW nRow2, _Func& rFunc)
+FindFormulaEditText(const CellStoreType& rStore, SCROW nRow1, SCROW nRow2, Func& rFunc)
 {
-    return FindElement2<CellStoreType, edittext_block, formula_block, _Func, _Func>(rStore, nRow1, nRow2, rFunc, rFunc);
+    return FindElement2<CellStoreType, edittext_block, formula_block, Func, Func>(rStore, nRow1, nRow2, rFunc, rFunc);
 }
 
-template<typename _Func>
-void ProcessNote(CellNoteStoreType& rStore, _Func& rFunc)
+template<typename Func>
+void ProcessNote(CellNoteStoreType& rStore, Func& rFunc)
 {
     FuncElseNoOp<size_t> aElse;
-    ProcessElements1<CellNoteStoreType, cellnote_block, _Func, FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
+    ProcessElements1<CellNoteStoreType, cellnote_block, Func, FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
 }
 
-template<typename _Func>
+template<typename Func>
 typename CellNoteStoreType::const_iterator
 ParseNote(
     const CellNoteStoreType::const_iterator& itPos, const CellNoteStoreType& rStore,
-    SCROW nStart, SCROW nEnd, _Func& rFunc)
+    SCROW nStart, SCROW nEnd, Func& rFunc)
 {
     FuncElseNoOp<size_t> aElse;
-    return ParseElements1<CellNoteStoreType, cellnote_block, _Func, FuncElseNoOp<size_t> >(
+    return ParseElements1<CellNoteStoreType, cellnote_block, Func, FuncElseNoOp<size_t> >(
         itPos, rStore, nStart, nEnd, rFunc, aElse);
 }
 
-template<typename _FuncElem>
+template<typename FuncElem>
 typename CellNoteStoreType::iterator
 ProcessNote(
-    const CellNoteStoreType::iterator& it, CellNoteStoreType& rStore, SCROW nRow1, SCROW nRow2, _FuncElem& rFuncElem)
+    const CellNoteStoreType::iterator& it, CellNoteStoreType& rStore, SCROW nRow1, SCROW nRow2, FuncElem& rFuncElem)
 {
     FuncElseNoOp<size_t> aElse;
     return ProcessElements1<
-        CellNoteStoreType, cellnote_block, _FuncElem, FuncElseNoOp<size_t> >(it, rStore, nRow1, nRow2, rFuncElem, aElse);
+        CellNoteStoreType, cellnote_block, FuncElem, FuncElseNoOp<size_t> >(it, rStore, nRow1, nRow2, rFuncElem, aElse);
 }
 
-template<typename _FuncElem>
+template<typename FuncElem>
 typename BroadcasterStoreType::iterator
 ProcessBroadcaster(
-    const BroadcasterStoreType::iterator& it, BroadcasterStoreType& rStore, SCROW nRow1, SCROW nRow2, _FuncElem& rFuncElem)
+    const BroadcasterStoreType::iterator& it, BroadcasterStoreType& rStore, SCROW nRow1, SCROW nRow2, FuncElem& rFuncElem)
 {
     FuncElseNoOp<size_t> aElse;
     return ProcessElements1<
-        BroadcasterStoreType, broadcaster_block, _FuncElem, FuncElseNoOp<size_t> >(it, rStore, nRow1, nRow2, rFuncElem, aElse);
+        BroadcasterStoreType, broadcaster_block, FuncElem, FuncElseNoOp<size_t> >(it, rStore, nRow1, nRow2, rFuncElem, aElse);
 }
 
 }
diff --git a/sc/inc/mtvfunctions.hxx b/sc/inc/mtvfunctions.hxx
index 028e73c96aae..f9052edfb27c 100644
--- a/sc/inc/mtvfunctions.hxx
+++ b/sc/inc/mtvfunctions.hxx
@@ -15,12 +15,12 @@
 
 namespace sc {
 
-template<typename _SizeT, typename _Ret = bool>
+template<typename SizeT, typename Ret = bool>
 struct FuncElseNoOp
 {
-    _Ret operator() (mdds::mtv::element_t, _SizeT, _SizeT) const
+    Ret operator() (mdds::mtv::element_t, SizeT, SizeT) const
     {
-        return _Ret();
+        return Ret();
     }
 };
 
@@ -28,19 +28,19 @@ struct FuncElseNoOp
  * Generic algorithm to parse blocks of multi_type_vector either partially
  * or fully.
  */
-template<typename _StoreT, typename _Func>
-typename _StoreT::const_iterator
+template<typename StoreT, typename Func>
+typename StoreT::const_iterator
 ParseBlock(
-    const typename _StoreT::const_iterator& itPos, const _StoreT& rStore, _Func& rFunc,
-    typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd)
+    const typename StoreT::const_iterator& itPos, const StoreT& rStore, Func& rFunc,
+    typename StoreT::size_type nStart, typename StoreT::size_type nEnd)
 {
-    typedef std::pair<typename _StoreT::const_iterator, typename _StoreT::size_type> PositionType;
+    typedef std::pair<typename StoreT::const_iterator, typename StoreT::size_type> PositionType;
 
     PositionType aPos = rStore.position(itPos, nStart);
-    typename _StoreT::const_iterator it = aPos.first;
-    typename _StoreT::size_type nOffset = aPos.second;
-    typename _StoreT::size_type nDataSize = 0;
-    typename _StoreT::size_type nTopRow = nStart;
+    typename StoreT::const_iterator it = aPos.first;
+    typename StoreT::size_type nOffset = aPos.second;
+    typename StoreT::size_type nDataSize = 0;
+    typename StoreT::size_type nTopRow = nStart;
 
     for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow += nDataSize)
     {
@@ -66,17 +66,17 @@ ParseBlock(
  * Non-const variant of the above function. TODO: Find a way to merge these
  * two in an elegant way.
  */
-template<typename _StoreT, typename _Func>
-typename _StoreT::iterator
-ProcessBlock(const typename _StoreT::iterator& itPos, _StoreT& rStore, _Func& rFunc, typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd)
+template<typename StoreT, typename Func>
+typename StoreT::iterator
+ProcessBlock(const typename StoreT::iterator& itPos, StoreT& rStore, Func& rFunc, typename StoreT::size_type nStart, typename StoreT::size_type nEnd)
 {
-    typedef std::pair<typename _StoreT::iterator, typename _StoreT::size_type> PositionType;
+    typedef std::pair<typename StoreT::iterator, typename StoreT::size_type> PositionType;
 
     PositionType aPos = rStore.position(itPos, nStart);
-    typename _StoreT::iterator it = aPos.first;
-    typename _StoreT::size_type nOffset = aPos.second;
-    typename _StoreT::size_type nDataSize = 0;
-    typename _StoreT::size_type nCurRow = nStart;
+    typename StoreT::iterator it = aPos.first;
+    typename StoreT::size_type nOffset = aPos.second;
+    typename StoreT::size_type nDataSize = 0;
+    typename StoreT::size_type nCurRow = nStart;
 
     for (; it != rStore.end() && nCurRow <= nEnd; ++it, nOffset = 0, nCurRow += nDataSize)
     {
@@ -98,39 +98,39 @@ ProcessBlock(const typename _StoreT::iterator& itPos, _StoreT& rStore, _Func& rF
     return it;
 }
 
-template<typename _BlkT, typename _ItrT, typename _NodeT, typename _FuncElem>
-void EachElem(_NodeT& rNode, size_t nOffset, size_t nDataSize, _FuncElem& rFuncElem)
+template<typename BlkT, typename ItrT, typename NodeT, typename FuncElem>
+void EachElem(NodeT& rNode, size_t nOffset, size_t nDataSize, FuncElem& rFuncElem)
 {
-    _ItrT it = _BlkT::begin(*rNode.data);
+    ItrT it = BlkT::begin(*rNode.data);
     std::advance(it, nOffset);
-    _ItrT itEnd = it;
+    ItrT itEnd = it;
     std::advance(itEnd, nDataSize);
     size_t nRow = rNode.position + nOffset;
     for (; it != itEnd; ++it, ++nRow)
         rFuncElem(nRow, *it);
 }
 
-template<typename _BlkT, typename _ItrT, typename _NodeT, typename _FuncElem>
-void EachElem(_NodeT& rNode, _FuncElem& rFuncElem)
+template<typename BlkT, typename ItrT, typename NodeT, typename FuncElem>
+void EachElem(NodeT& rNode, FuncElem& rFuncElem)
 {
-    _ItrT it = _BlkT::begin(*rNode.data);
-    _ItrT itEnd = _BlkT::end(*rNode.data);
+    ItrT it = BlkT::begin(*rNode.data);
+    ItrT itEnd = BlkT::end(*rNode.data);
     size_t nRow = rNode.position;
     for (; it != itEnd; ++it, ++nRow)
         rFuncElem(nRow, *it);
 }
 
-template<typename _BlkT, typename _StoreT, typename _FuncElem>
-std::pair<typename _StoreT::const_iterator, size_t>
+template<typename BlkT, typename StoreT, typename FuncElem>
+std::pair<typename StoreT::const_iterator, size_t>
 CheckElem(
-    const _StoreT& rStore, const typename _StoreT::const_iterator& it, size_t nOffset, size_t nDataSize,
-    _FuncElem& rFuncElem)
+    const StoreT& rStore, const typename StoreT::const_iterator& it, size_t nOffset, size_t nDataSize,
+    FuncElem& rFuncElem)
 {
-    typedef std::pair<typename _StoreT::const_iterator, size_t> PositionType;
+    typedef std::pair<typename StoreT::const_iterator, size_t> PositionType;
 
-    typename _BlkT::const_iterator itData = _BlkT::begin(*it->data);
+    typename BlkT::const_iterator itData = BlkT::begin(*it->data);
     std::advance(itData, nOffset);
-    typename _BlkT::const_iterator itDataEnd = itData;
+    typename BlkT::const_iterator itDataEnd = itData;
     std::advance(itDataEnd, nDataSize);
     size_t nTopRow = it->position + nOffset;
     size_t nRow = nTopRow;
@@ -143,38 +143,38 @@ CheckElem(
     return PositionType(rStore.end(), 0);
 }
 
-template<typename _StoreT, typename _BlkT, typename _FuncElem, typename _FuncElse>
-void ParseElements1(const _StoreT& rStore, _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+template<typename StoreT, typename BlkT, typename FuncElem, typename FuncElse>
+void ParseElements1(const StoreT& rStore, FuncElem& rFuncElem, FuncElse& rFuncElse)
 {
-    typename _StoreT::size_type nTopRow = 0, nDataSize = 0;
-    typename _StoreT::const_iterator it = rStore.begin(), itEnd = rStore.end();
+    typename StoreT::size_type nTopRow = 0, nDataSize = 0;
+    typename StoreT::const_iterator it = rStore.begin(), itEnd = rStore.end();
     for (; it != itEnd; ++it, nTopRow += nDataSize)
     {
         nDataSize = it->size;
-        if (it->type != _BlkT::block_type)
+        if (it->type != BlkT::block_type)
         {
             rFuncElse(it->type, nTopRow, nDataSize);
             continue;
         }
 
-        EachElem<_BlkT, typename _BlkT::const_iterator>(*it, rFuncElem);
+        EachElem<BlkT, typename BlkT::const_iterator>(*it, rFuncElem);
     }
 }
 
-template<typename _StoreT, typename _BlkT, typename _FuncElem, typename _FuncElse>
-typename _StoreT::const_iterator
+template<typename StoreT, typename BlkT, typename FuncElem, typename FuncElse>
+typename StoreT::const_iterator
 ParseElements1(
-    const typename _StoreT::const_iterator& itPos, const _StoreT& rStore,
-    typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd,
-    _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+    const typename StoreT::const_iterator& itPos, const StoreT& rStore,
+    typename StoreT::size_type nStart, typename StoreT::size_type nEnd,
+    FuncElem& rFuncElem, FuncElse& rFuncElse)
 {
-    typedef std::pair<typename _StoreT::const_iterator, typename _StoreT::size_type> PositionType;
+    typedef std::pair<typename StoreT::const_iterator, typename StoreT::size_type> PositionType;
 
     PositionType aPos = rStore.position(itPos, nStart);
-    typename _StoreT::const_iterator it = aPos.first;
-    typename _StoreT::size_type nOffset = aPos.second;
-    typename _StoreT::size_type nDataSize = 0;
-    typename _StoreT::size_type nTopRow = nStart;
+    typename StoreT::const_iterator it = aPos.first;
+    typename StoreT::size_type nOffset = aPos.second;
+    typename StoreT::size_type nDataSize = 0;
+    typename StoreT::size_type nTopRow = nStart;
 
     for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow += nDataSize)
     {
@@ -187,8 +187,8 @@ ParseElements1(
             bLastBlock = true;
         }
 
-        if (it->type == _BlkT::block_type)
-            EachElem<_BlkT, typename _BlkT::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
+        if (it->type == BlkT::block_type)
+            EachElem<BlkT, typename BlkT::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
         else
             rFuncElse(it->type, nTopRow, nDataSize);
 
@@ -199,19 +199,19 @@ ParseElements1(
     return it;
 };
 
-template<typename _StoreT, typename _Blk1, typename _Blk2, typename _FuncElem, typename _FuncElse>
-typename _StoreT::const_iterator
+template<typename StoreT, typename Blk1, typename Blk2, typename FuncElem, typename FuncElse>
+typename StoreT::const_iterator
 ParseElements2(
-    const typename _StoreT::const_iterator& itPos, const _StoreT& rStore, typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd,
-    _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+    const typename StoreT::const_iterator& itPos, const StoreT& rStore, typename StoreT::size_type nStart, typename StoreT::size_type nEnd,
+    FuncElem& rFuncElem, FuncElse& rFuncElse)
 {
-    typedef std::pair<typename _StoreT::const_iterator, typename _StoreT::size_type> PositionType;
+    typedef std::pair<typename StoreT::const_iterator, typename StoreT::size_type> PositionType;
 
     PositionType aPos = rStore.position(itPos, nStart);
-    typename _StoreT::const_iterator it = aPos.first;
-    typename _StoreT::size_type nOffset = aPos.second;
-    typename _StoreT::size_type nDataSize = 0;
-    typename _StoreT::size_type nTopRow = nStart;
+    typename StoreT::const_iterator it = aPos.first;
+    typename StoreT::size_type nOffset = aPos.second;
+    typename StoreT::size_type nDataSize = 0;
+    typename StoreT::size_type nTopRow = nStart;
 
     for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow += nDataSize)
     {
@@ -226,11 +226,11 @@ ParseElements2(
 
         switch (it->type)
         {
-            case _Blk1::block_type:
-                EachElem<_Blk1, typename _Blk1::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
+            case Blk1::block_type:
+                EachElem<Blk1, typename Blk1::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
             break;
-            case _Blk2::block_type:
-                EachElem<_Blk2, typename _Blk2::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
+            case Blk2::block_type:
+                EachElem<Blk2, typename Blk2::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
             break;
             default:
                 rFuncElse(it->type, nTopRow, nDataSize);
@@ -243,19 +243,19 @@ ParseElements2(
     return it;
 }
 
-template<typename _StoreT, typename _Blk1, typename _Blk2, typename _Blk3, typename _Blk4, typename _FuncElem, typename _FuncElse>
-typename _StoreT::const_iterator
+template<typename StoreT, typename Blk1, typename Blk2, typename Blk3, typename Blk4, typename FuncElem, typename FuncElse>
+typename StoreT::const_iterator
 ParseElements4(
-    const typename _StoreT::const_iterator& itPos, const _StoreT& rStore, typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd,
-    _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+    const typename StoreT::const_iterator& itPos, const StoreT& rStore, typename StoreT::size_type nStart, typename StoreT::size_type nEnd,
+    FuncElem& rFuncElem, FuncElse& rFuncElse)
 {
-    typedef std::pair<typename _StoreT::const_iterator, typename _StoreT::size_type> PositionType;
+    typedef std::pair<typename StoreT::const_iterator, typename StoreT::size_type> PositionType;
 
     PositionType aPos = rStore.position(itPos, nStart);
-    typename _StoreT::const_iterator it = aPos.first;
-    typename _StoreT::size_type nOffset = aPos.second;
-    typename _StoreT::size_type nDataSize = 0;
-    typename _StoreT::size_type nTopRow = nStart;
+    typename StoreT::const_iterator it = aPos.first;
+    typename StoreT::size_type nOffset = aPos.second;
+    typename StoreT::size_type nDataSize = 0;
+    typename StoreT::size_type nTopRow = nStart;
 
     for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow += nDataSize)
     {
@@ -270,17 +270,17 @@ ParseElements4(
 
         switch (it->type)
         {
-            case _Blk1::block_type:
-                EachElem<_Blk1, typename _Blk1::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
+            case Blk1::block_type:
+                EachElem<Blk1, typename Blk1::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
             break;
-            case _Blk2::block_type:
-                EachElem<_Blk2, typename _Blk2::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
+            case Blk2::block_type:
+                EachElem<Blk2, typename Blk2::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
             break;
-            case _Blk3::block_type:
-                EachElem<_Blk3, typename _Blk3::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
+            case Blk3::block_type:
+                EachElem<Blk3, typename Blk3::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
             break;
-            case _Blk4::block_type:
-                EachElem<_Blk4, typename _Blk4::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
+            case Blk4::block_type:
+                EachElem<Blk4, typename Blk4::const_iterator>(*it, nOffset, nDataSize, rFuncElem);
             break;
             default:
                 rFuncElse(it->type, nTopRow, nDataSize);
@@ -293,41 +293,41 @@ ParseElements4(
     return it;
 }
 
-template<typename _StoreT, typename _BlkT, typename _FuncElem, typename _FuncElse>
-void ProcessElements1(_StoreT& rStore, _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+template<typename StoreT, typename BlkT, typename FuncElem, typename FuncElse>
+void ProcessElements1(StoreT& rStore, FuncElem& rFuncElem, FuncElse& rFuncElse)
 {
-    typename _StoreT::size_type nTopRow = 0, nDataSize = 0;
-    typename _StoreT::iterator it = rStore.begin(), itEnd = rStore.end();
+    typename StoreT::size_type nTopRow = 0, nDataSize = 0;
+    typename StoreT::iterator it = rStore.begin(), itEnd = rStore.end();
     for (; it != itEnd; ++it, nTopRow += nDataSize)
     {
         nDataSize = it->size;
-        if (it->type != _BlkT::block_type)
+        if (it->type != BlkT::block_type)
         {
             rFuncElse(it->type, nTopRow, nDataSize);
             continue;
         }
 
-        EachElem<_BlkT, typename _BlkT::iterator>(*it, rFuncElem);
+        EachElem<BlkT, typename BlkT::iterator>(*it, rFuncElem);
     }
 }
 
 /**
  * This variant specifies start and end positions.
  */
-template<typename _StoreT, typename _BlkT, typename _FuncElem, typename _FuncElse>
-typename _StoreT::iterator
+template<typename StoreT, typename BlkT, typename FuncElem, typename FuncElse>
+typename StoreT::iterator
 ProcessElements1(
-    const typename _StoreT::iterator& itPos, _StoreT& rStore,
-    typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd,
-    _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+    const typename StoreT::iterator& itPos, StoreT& rStore,
+    typename StoreT::size_type nStart, typename StoreT::size_type nEnd,
+    FuncElem& rFuncElem, FuncElse& rFuncElse)
 {
-    typedef std::pair<typename _StoreT::iterator, typename _StoreT::size_type> PositionType;
+    typedef std::pair<typename StoreT::iterator, typename StoreT::size_type> PositionType;
 
     PositionType aPos = rStore.position(itPos, nStart);
-    typename _StoreT::iterator it = aPos.first;
-    typename _StoreT::size_type nOffset = aPos.second;
-    typename _StoreT::size_type nDataSize = 0;
-    typename _StoreT::size_type nTopRow = nStart;
+    typename StoreT::iterator it = aPos.first;
+    typename StoreT::size_type nOffset = aPos.second;
+    typename StoreT::size_type nDataSize = 0;
+    typename StoreT::size_type nTopRow = nStart;
 
     for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow += nDataSize)
     {
@@ -340,8 +340,8 @@ ProcessElements1(
             bLastBlock = true;
         }
 
-        if (it->type == _BlkT::block_type)
-            EachElem<_BlkT, typename _BlkT::iterator>(*it, nOffset, nDataSize, rFuncElem);
+        if (it->type == BlkT::block_type)
+            EachElem<BlkT, typename BlkT::iterator>(*it, nOffset, nDataSize, rFuncElem);
         else
             rFuncElse(it->type, nTopRow, nDataSize);
 
@@ -352,21 +352,21 @@ ProcessElements1(
     return it;
 };
 
-template<typename _StoreT, typename _Blk1, typename _Blk2, typename _FuncElem, typename _FuncElse>
-void ProcessElements2(_StoreT& rStore, _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+template<typename StoreT, typename Blk1, typename Blk2, typename FuncElem, typename FuncElse>
+void ProcessElements2(StoreT& rStore, FuncElem& rFuncElem, FuncElse& rFuncElse)
 {
-    typename _StoreT::size_type nTopRow = 0, nDataSize = 0;
-    typename _StoreT::iterator it = rStore.begin(), itEnd = rStore.end();
+    typename StoreT::size_type nTopRow = 0, nDataSize = 0;
+    typename StoreT::iterator it = rStore.begin(), itEnd = rStore.end();
     for (; it != itEnd; ++it, nTopRow += nDataSize)
     {
         nDataSize = it->size;
         switch (it->type)
         {
-            case _Blk1::block_type:
-                EachElem<_Blk1, typename _Blk1::iterator>(*it, rFuncElem);
+            case Blk1::block_type:
+                EachElem<Blk1, typename Blk1::iterator>(*it, rFuncElem);
             break;
-            case _Blk2::block_type:
-                EachElem<_Blk2, typename _Blk2::iterator>(*it, rFuncElem);
+            case Blk2::block_type:
+                EachElem<Blk2, typename Blk2::iterator>(*it, rFuncElem);
             break;
             default:
                 rFuncElse(it->type, nTopRow, nDataSize);
@@ -374,20 +374,20 @@ void ProcessElements2(_StoreT& rStore, _FuncElem& rFuncElem, _FuncElse& rFuncEls
     }
 }
 
-template<typename _StoreT, typename _Blk1, typename _FuncElem, typename _FuncElse>
-std::pair<typename _StoreT::const_iterator, typename _StoreT::size_type>
+template<typename StoreT, typename Blk1, typename FuncElem, typename FuncElse>
+std::pair<typename StoreT::const_iterator, typename StoreT::size_type>
 FindElement1(
-    const _StoreT& rStore, typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd,
-    _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+    const StoreT& rStore, typename StoreT::size_type nStart, typename StoreT::size_type nEnd,
+    FuncElem& rFuncElem, FuncElse& rFuncElse)
 {
-    typedef std::pair<typename _StoreT::const_iterator, typename _StoreT::size_type> PositionType;
-    typedef std::pair<typename _StoreT::size_type, bool> ElseRetType;
+    typedef std::pair<typename StoreT::const_iterator, typename StoreT::size_type> PositionType;
+    typedef std::pair<typename StoreT::size_type, bool> ElseRetType;
 
     PositionType aPos = rStore.position(nStart);
-    typename _StoreT::const_iterator it = aPos.first;
-    typename _StoreT::size_type nOffset = aPos.second;
-    typename _StoreT::size_type nDataSize = 0;
-    typename _StoreT::size_type nTopRow = nStart;
+    typename StoreT::const_iterator it = aPos.first;
+    typename StoreT::size_type nOffset = aPos.second;
+    typename StoreT::size_type nDataSize = 0;
+    typename StoreT::size_type nTopRow = nStart;
 
     for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow += nDataSize)
     {
@@ -402,9 +402,9 @@ FindElement1(
 
         switch (it->type)
         {
-            case _Blk1::block_type:
+            case Blk1::block_type:
             {
-                PositionType aRet = CheckElem<_Blk1>(rStore, it, nOffset, nDataSize, rFuncElem);
+                PositionType aRet = CheckElem<Blk1>(rStore, it, nOffset, nDataSize, rFuncElem);
                 if (aRet.first != rStore.end())
                     return aRet;
             }
@@ -424,20 +424,20 @@ FindElement1(
     return PositionType(rStore.end(), 0);
 }
 
-template<typename _StoreT, typename _Blk1, typename _Blk2, typename _FuncElem, typename _FuncElse>
-std::pair<typename _StoreT::const_iterator, typename _StoreT::size_type>
+template<typename StoreT, typename Blk1, typename Blk2, typename FuncElem, typename FuncElse>
+std::pair<typename StoreT::const_iterator, typename StoreT::size_type>
 FindElement2(
-    const _StoreT& rStore, typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd,
-    _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+    const StoreT& rStore, typename StoreT::size_type nStart, typename StoreT::size_type nEnd,
+    FuncElem& rFuncElem, FuncElse& rFuncElse)
 {
-    typedef std::pair<typename _StoreT::const_iterator, typename _StoreT::size_type> PositionType;
-    typedef std::pair<typename _StoreT::size_type, bool> ElseRetType;
+    typedef std::pair<typename StoreT::const_iterator, typename StoreT::size_type> PositionType;
+    typedef std::pair<typename StoreT::size_type, bool> ElseRetType;
 
     PositionType aPos = rStore.position(nStart);
-    typename _StoreT::const_iterator it = aPos.first;
-    typename _StoreT::size_type nOffset = aPos.second;
-    typename _StoreT::size_type nDataSize = 0;
-    typename _StoreT::size_type nTopRow = nStart;
+    typename StoreT::const_iterator it = aPos.first;
+    typename StoreT::size_type nOffset = aPos.second;
+    typename StoreT::size_type nDataSize = 0;
+    typename StoreT::size_type nTopRow = nStart;
 
     for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow += nDataSize)
     {
@@ -452,16 +452,16 @@ FindElement2(
 
         switch (it->type)
         {
-            case _Blk1::block_type:
+            case Blk1::block_type:
             {
-                PositionType aRet = CheckElem<_Blk1>(rStore, it, nOffset, nDataSize, rFuncElem);
+                PositionType aRet = CheckElem<Blk1>(rStore, it, nOffset, nDataSize, rFuncElem);
                 if (aRet.first != rStore.end())
                     return aRet;
             }
             break;
-            case _Blk2::block_type:
+            case Blk2::block_type:
             {
-                PositionType aRet = CheckElem<_Blk2>(rStore, it, nOffset, nDataSize, rFuncElem);
+                PositionType aRet = CheckElem<Blk2>(rStore, it, nOffset, nDataSize, rFuncElem);
                 if (aRet.first != rStore.end())
                     return aRet;
             }
diff --git a/sc/inc/sharedformula.hxx b/sc/inc/sharedformula.hxx
index b3d761585a35..f4c8ab018532 100644
--- a/sc/inc/sharedformula.hxx
+++ b/sc/inc/sharedformula.hxx
@@ -29,10 +29,10 @@ public:
      * Group formula cells stored in the passed container. The formula cells
      * in the container are assumed to be all <b>non-shared</b>.
      */
-    template<typename _Iter>
-    static void groupFormulaCells(const _Iter& itBeg, const _Iter& itEnd)
+    template<typename Iter>
+    static void groupFormulaCells(const Iter& itBeg, const Iter& itEnd)
     {
-        _Iter it = itBeg;
+        Iter it = itBeg;
         ScFormulaCell* pPrev = *it;
         ScFormulaCell* pCur = nullptr;
         for (++it; it != itEnd; ++it, pPrev = pCur)
diff --git a/sc/inc/stlalgorithm.hxx b/sc/inc/stlalgorithm.hxx
index 7cc5eebafece..678f30676c9c 100644
--- a/sc/inc/stlalgorithm.hxx
+++ b/sc/inc/stlalgorithm.hxx
@@ -21,7 +21,7 @@ namespace sc {
  * Custom allocator for STL container to ensure that the base address of
  * allocated storage is aligned to a specified boundary.
  */
-template<typename T, size_t _Alignment>
+template<typename T, size_t Alignment>
 class AlignedAllocator
 {
 public:
@@ -36,17 +36,17 @@ public:
     typedef T& reference;
     typedef const T& const_reference;
 
-    template<typename _Type2>
+    template<typename Type2>
     struct rebind
     {
-        typedef AlignedAllocator<_Type2,_Alignment> other;
+        typedef AlignedAllocator<Type2,Alignment> other;
     };
 
     AlignedAllocator() {}
     ~AlignedAllocator() {}
 
-    template<typename _Type2>
-    AlignedAllocator(const AlignedAllocator<_Type2,_Alignment>&) {}
+    template<typename Type2>
+    AlignedAllocator(const AlignedAllocator<Type2,Alignment>&) {}
 
     static void construct(T* p, const value_type& val) { new(p) value_type(val); }
     static void destroy(T* p)
@@ -65,7 +65,7 @@ public:
 
     static pointer allocate(size_type n)
     {
-        return static_cast<pointer>(rtl_allocateAlignedMemory(_Alignment, n*sizeof(value_type)));
+        return static_cast<pointer>(rtl_allocateAlignedMemory(Alignment, n*sizeof(value_type)));
     }
 
     static void deallocate(pointer p, size_type)
diff --git a/sc/qa/unit/helper/qahelper.hxx b/sc/qa/unit/helper/qahelper.hxx
index 083e2d107676..0d089cedf26f 100644
--- a/sc/qa/unit/helper/qahelper.hxx
+++ b/sc/qa/unit/helper/qahelper.hxx
@@ -138,8 +138,8 @@ SCQAHELPER_DLLPUBLIC ScTokenArray* compileFormula(
     ScDocument* pDoc, const OUString& rFormula, const ScAddress* pPos = nullptr,
     formula::FormulaGrammar::Grammar eGram = formula::FormulaGrammar::GRAM_NATIVE );
 
-template<size_t _Size>
-bool checkOutput(ScDocument* pDoc, const ScRange& aOutRange, const char* aOutputCheck[][_Size], const char* pCaption)
+template<size_t Size>
+bool checkOutput(ScDocument* pDoc, const ScRange& aOutRange, const char* aOutputCheck[][Size], const char* pCaption)
 {
     bool bResult = true;
     const ScAddress& s = aOutRange.aStart;
diff --git a/sc/qa/unit/ucalc.cxx b/sc/qa/unit/ucalc.cxx
index f46cd76808ff..d10ac5bbdff5 100644
--- a/sc/qa/unit/ucalc.cxx
+++ b/sc/qa/unit/ucalc.cxx
@@ -1014,8 +1014,8 @@ struct HoriIterCheck
     const char* pVal;
 };
 
-template<size_t _Size>
-bool checkHorizontalIterator(ScDocument* pDoc, const char* pData[][_Size], size_t nDataCount, const HoriIterCheck* pChecks, size_t nCheckCount)
+template<size_t Size>
+bool checkHorizontalIterator(ScDocument* pDoc, const char* pData[][Size], size_t nDataCount, const HoriIterCheck* pChecks, size_t nCheckCount)
 {
     ScAddress aPos(0,0,0);
     Test::insertRangeData(pDoc, aPos, pData, nDataCount);
diff --git a/sc/qa/unit/ucalc.hxx b/sc/qa/unit/ucalc.hxx
index 9c930169041f..9427367ca6a6 100644
--- a/sc/qa/unit/ucalc.hxx
+++ b/sc/qa/unit/ucalc.hxx
@@ -58,17 +58,17 @@ public:
     static void setCalcAsShown(ScDocument* pDoc, bool bCalcAsShown);
 
 
-    template<size_t _Size>
+    template<size_t Size>
     static ScRange insertRangeData(
-        ScDocument* pDoc, const ScAddress& rPos, const char* aData[][_Size], size_t nRowCount )
+        ScDocument* pDoc, const ScAddress& rPos, const char* aData[][Size], size_t nRowCount )
     {
         ScRange aRange(rPos);
-        aRange.aEnd.SetCol(rPos.Col()+_Size-1);
+        aRange.aEnd.SetCol(rPos.Col()+Size-1);
         aRange.aEnd.SetRow(rPos.Row()+nRowCount-1);
 
         clearRange(pDoc, aRange);
 
-        for (size_t i = 0; i < _Size; ++i)
+        for (size_t i = 0; i < Size; ++i)
         {
             for (size_t j = 0; j < nRowCount; ++j)
             {
diff --git a/sc/qa/unit/ucalc_formula.cxx b/sc/qa/unit/ucalc_formula.cxx
index cf1944b6eaf2..a58ec4d34d99 100644
--- a/sc/qa/unit/ucalc_formula.cxx
+++ b/sc/qa/unit/ucalc_formula.cxx
@@ -4425,14 +4425,14 @@ struct StrStrCheck {
     const char* pRes;
 };
 
-template<size_t _DataSize, size_t _FormulaSize, int _Type>
-void runTestMATCH(ScDocument* pDoc, const char* aData[_DataSize], StrStrCheck aChecks[_FormulaSize])
+template<size_t DataSize, size_t FormulaSize, int Type>
+void runTestMATCH(ScDocument* pDoc, const char* aData[DataSize], StrStrCheck aChecks[FormulaSize])
 {
-    size_t nDataSize = _DataSize;
+    size_t nDataSize = DataSize;
     for (size_t i = 0; i < nDataSize; ++i)
         pDoc->SetString(0, i, 0, OUString::createFromAscii(aData[i]));
 
-    for (size_t i = 0; i < _FormulaSize; ++i)
+    for (size_t i = 0; i < FormulaSize; ++i)
     {
         pDoc->SetString(1, i, 0, OUString::createFromAscii(aChecks[i].pVal));
 
@@ -4442,17 +4442,17 @@ void runTestMATCH(ScDocument* pDoc, const char* aData[_DataSize], StrStrCheck aC
         aBuf.append(";A1:A");
         aBuf.append(static_cast<sal_Int32>(nDataSize));
         aBuf.append(";");
-        aBuf.append(static_cast<sal_Int32>(_Type));
+        aBuf.append(static_cast<sal_Int32>(Type));
         aBuf.append(")");
         OUString aFormula = aBuf.makeStringAndClear();
         pDoc->SetString(2, i, 0, aFormula);
     }
 
     pDoc->CalcAll();
-    Test::printRange(pDoc, ScRange(0, 0, 0, 2, _FormulaSize-1, 0), "MATCH");
+    Test::printRange(pDoc, ScRange(0, 0, 0, 2, FormulaSize-1, 0), "MATCH");
 
     // verify the results.
-    for (size_t i = 0; i < _FormulaSize; ++i)
+    for (size_t i = 0; i < FormulaSize; ++i)
     {
         OUString aStr = pDoc->GetString(2, i, 0);
         if (!aStr.equalsAscii(aChecks[i].pRes))
@@ -4464,14 +4464,14 @@ void runTestMATCH(ScDocument* pDoc, const char* aData[_DataSize], StrStrCheck aC
     }
 }
 
-template<size_t _DataSize, size_t _FormulaSize, int _Type>
-void runTestHorizontalMATCH(ScDocument* pDoc, const char* aData[_DataSize], StrStrCheck aChecks[_FormulaSize])
+template<size_t DataSize, size_t FormulaSize, int Type>
+void runTestHorizontalMATCH(ScDocument* pDoc, const char* aData[DataSize], StrStrCheck aChecks[FormulaSize])
 {
-    size_t nDataSize = _DataSize;
+    size_t nDataSize = DataSize;
     for (size_t i = 0; i < nDataSize; ++i)
         pDoc->SetString(i, 0, 0, OUString::createFromAscii(aData[i]));
 
-    for (size_t i = 0; i < _FormulaSize; ++i)
+    for (size_t i = 0; i < FormulaSize; ++i)
     {
         pDoc->SetString(i, 1, 0, OUString::createFromAscii(aChecks[i].pVal));
 
@@ -4482,17 +4482,17 @@ void runTestHorizontalMATCH(ScDocument* pDoc, const char* aData[_DataSize], StrS
         aBuf.append("2;A1:");
         aBuf.append(static_cast<sal_Unicode>('A'+nDataSize));
         aBuf.append("1;");
-        aBuf.append(static_cast<sal_Int32>(_Type));
+        aBuf.append(static_cast<sal_Int32>(Type));
         aBuf.append(")");
         OUString aFormula = aBuf.makeStringAndClear();
         pDoc->SetString(i, 2, 0, aFormula);
     }
 
     pDoc->CalcAll();
-    Test::printRange(pDoc, ScRange(0, 0, 0, _FormulaSize-1, 2, 0), "MATCH");
+    Test::printRange(pDoc, ScRange(0, 0, 0, FormulaSize-1, 2, 0), "MATCH");
 
     // verify the results.
-    for (size_t i = 0; i < _FormulaSize; ++i)
+    for (size_t i = 0; i < FormulaSize; ++i)
     {
         OUString aStr = pDoc->GetString(i, 2, 0);
         if (!aStr.equalsAscii(aChecks[i].pRes))
diff --git a/sc/qa/unit/ucalc_pivottable.cxx b/sc/qa/unit/ucalc_pivottable.cxx
index ef1150587d7e..c8aa1b3930cf 100644
--- a/sc/qa/unit/ucalc_pivottable.cxx
+++ b/sc/qa/unit/ucalc_pivottable.cxx
@@ -41,8 +41,8 @@ struct DPFieldDef
     bool bRepeatItemLabels;
 };
 
-template<size_t _Size>
-ScRange insertDPSourceData(ScDocument* pDoc, DPFieldDef aFields[], size_t nFieldCount, const char* aData[][_Size], size_t nDataCount)
+template<size_t Size>
+ScRange insertDPSourceData(ScDocument* pDoc, DPFieldDef aFields[], size_t nFieldCount, const char* aData[][Size], size_t nDataCount)
 {
     // Insert field names in row 0.
     for (size_t i = 0; i < nFieldCount; ++i)
@@ -72,10 +72,10 @@ ScRange insertDPSourceData(ScDocument* pDoc, DPFieldDef aFields[], size_t nField
     return aSrcRange;
 }
 
-template<size_t _Size>
-bool checkDPTableOutput(ScDocument* pDoc, const ScRange& aOutRange, const char* aOutputCheck[][_Size], const char* pCaption)
+template<size_t Size>
+bool checkDPTableOutput(ScDocument* pDoc, const ScRange& aOutRange, const char* aOutputCheck[][Size], const char* pCaption)
 {
-    return checkOutput<_Size>(pDoc, aOutRange, aOutputCheck, pCaption);
+    return checkOutput<Size>(pDoc, aOutRange, aOutputCheck, pCaption);
 }
 
 ScDPObject* createDPFromSourceDesc(
diff --git a/sc/source/core/data/cellvalue.cxx b/sc/source/core/data/cellvalue.cxx
index bba0b956fed3..d6b71f111fb9 100644
--- a/sc/source/core/data/cellvalue.cxx
+++ b/sc/source/core/data/cellvalue.cxx
@@ -33,8 +33,8 @@ CellType adjustCellType( CellType eOrig )
     return eOrig;
 }
 
-template<typename _T>
-OUString getString( const _T& rVal )
+template<typename T>
+OUString getString( const T& rVal )
 {
     if (rVal.meType == CELLTYPE_STRING)
         return rVal.mpString->getString();
@@ -75,8 +75,8 @@ bool equalsFormulaCells( const ScFormulaCell* p1, const ScFormulaCell* p2 )
     return true;
 }
 
-template<typename _T>
-bool equalsWithoutFormatImpl( const _T& left, const _T& right )
+template<typename T>
+bool equalsWithoutFormatImpl( const T& left, const T& right )
 {
     CellType eType1 = adjustCellType(left.meType);
     CellType eType2 = adjustCellType(right.meType);
@@ -154,8 +154,8 @@ bool hasNumericImpl( CellType eType, ScFormulaCell* pFormula )
     }
 }
 
-template<typename _CellT>
-OUString getStringImpl( const _CellT& rCell, const ScDocument* pDoc )
+template<typename CellT>
+OUString getStringImpl( const CellT& rCell, const ScDocument* pDoc )
 {
     switch (rCell.meType)
     {
diff --git a/sc/source/core/data/column2.cxx b/sc/source/core/data/column2.cxx
index 3c2986ee9812..8921787791ec 100644
--- a/sc/source/core/data/column2.cxx
+++ b/sc/source/core/data/column2.cxx
@@ -2307,16 +2307,16 @@ void ScColumn::FillMatrix( ScMatrix& rMat, size_t nMatCol, SCROW nRow1, SCROW nR
 
 namespace {
 
-template<typename _Blk>
+template<typename Blk>
 void getBlockIterators(
     const sc::CellStoreType::iterator& it, size_t& rLenRemain,
-    typename _Blk::iterator& rData, typename _Blk::iterator& rDataEnd )
+    typename Blk::iterator& rData, typename Blk::iterator& rDataEnd )
 {
-    rData = _Blk::begin(*it->data);
+    rData = Blk::begin(*it->data);
     if (rLenRemain >= it->size)
     {
         // Block is shorter than the remaining requested length.
-        rDataEnd = _Blk::end(*it->data);
+        rDataEnd = Blk::end(*it->data);
         rLenRemain -= it->size;
     }
     else
diff --git a/sc/source/core/data/dociter.cxx b/sc/source/core/data/dociter.cxx
index af2c6de284ed..db673758410e 100644
--- a/sc/source/core/data/dociter.cxx
+++ b/sc/source/core/data/dociter.cxx
@@ -56,16 +56,16 @@ using ::std::set;
 
 namespace {
 
-template<typename _Iter>
-void incBlock(std::pair<_Iter, size_t>& rPos)
+template<typename Iter>
+void incBlock(std::pair<Iter, size_t>& rPos)
 {
     // Move to the next block.
     ++rPos.first;
     rPos.second = 0;
 }
 
-template<typename _Iter>
-void decBlock(std::pair<_Iter, size_t>& rPos)
+template<typename Iter>
+void decBlock(std::pair<Iter, size_t>& rPos)
 {
     // Move to the last element of the previous block.
     --rPos.first;
diff --git a/sc/source/core/data/segmenttree.cxx b/sc/source/core/data/segmenttree.cxx
index d9e60bcc89f8..7159d9c00537 100644
--- a/sc/source/core/data/segmenttree.cxx
+++ b/sc/source/core/data/segmenttree.cxx
@@ -26,12 +26,12 @@
 
 using ::std::numeric_limits;
 
-template<typename _ValueType, typename _ExtValueType = _ValueType>
+template<typename ValueType_, typename ExtValueType_ = ValueType_>
 class ScFlatSegmentsImpl
 {
 public:
-    typedef _ValueType ValueType;
-    typedef _ExtValueType ExtValueType;
+    typedef ValueType_ ValueType;
+    typedef ExtValueType_ ExtValueType;
 
     struct RangeData
     {
@@ -71,27 +71,27 @@ private:
     bool mbTreeSearchEnabled:1;
 };
 
-template<typename _ValueType, typename _ExtValueType>
-ScFlatSegmentsImpl<_ValueType, _ExtValueType>::ScFlatSegmentsImpl(SCCOLROW nMax, ValueType nDefault) :
+template<typename ValueType_, typename ExtValueType_>
+ScFlatSegmentsImpl<ValueType_, ExtValueType_>::ScFlatSegmentsImpl(SCCOLROW nMax, ValueType nDefault) :
     maSegments(0, nMax+1, nDefault),
     mbTreeSearchEnabled(true)
 {
 }
 
-template<typename _ValueType, typename _ExtValueType>
-ScFlatSegmentsImpl<_ValueType, _ExtValueType>::ScFlatSegmentsImpl(const ScFlatSegmentsImpl<_ValueType, _ExtValueType>& r) :
+template<typename ValueType_, typename ExtValueType_>
+ScFlatSegmentsImpl<ValueType_, ExtValueType_>::ScFlatSegmentsImpl(const ScFlatSegmentsImpl<ValueType_, ExtValueType_>& r) :
     maSegments(r.maSegments),
     mbTreeSearchEnabled(r.mbTreeSearchEnabled)
 {
 }
 
-template<typename _ValueType, typename _ExtValueType>
-ScFlatSegmentsImpl<_ValueType, _ExtValueType>::~ScFlatSegmentsImpl()
+template<typename ValueType_, typename ExtValueType_>
+ScFlatSegmentsImpl<ValueType_, ExtValueType_>::~ScFlatSegmentsImpl()
 {
 }
 
-template<typename _ValueType, typename _ExtValueType>
-bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::setValue(SCCOLROW nPos1, SCCOLROW nPos2, ValueType nValue)
+template<typename ValueType_, typename ExtValueType_>
+bool ScFlatSegmentsImpl<ValueType_, ExtValueType_>::setValue(SCCOLROW nPos1, SCCOLROW nPos2, ValueType nValue)
 {
     ::std::pair<typename fst_type::const_iterator, bool> ret;
     ret = maSegments.insert(maItr, nPos1, nPos2+1, nValue);
@@ -99,8 +99,8 @@ bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::setValue(SCCOLROW nPos1, SCC
     return ret.second;
 }
 
-template<typename _ValueType, typename _ExtValueType>
-typename ScFlatSegmentsImpl<_ValueType, _ExtValueType>::ValueType ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getValue(SCCOLROW nPos)
+template<typename ValueType_, typename ExtValueType_>
+typename ScFlatSegmentsImpl<ValueType_, ExtValueType_>::ValueType ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getValue(SCCOLROW nPos)
 {
     ValueType nValue = 0;
     if (!mbTreeSearchEnabled)
@@ -116,9 +116,9 @@ typename ScFlatSegmentsImpl<_ValueType, _ExtValueType>::ValueType ScFlatSegments
     return nValue;
 }
 
-template<typename _ValueType, typename _ExtValueType>
-typename ScFlatSegmentsImpl<_ValueType, _ExtValueType>::ExtValueType
-ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getSumValue(SCCOLROW nPos1, SCCOLROW nPos2)
+template<typename ValueType_, typename ExtValueType_>
+typename ScFlatSegmentsImpl<ValueType_, ExtValueType_>::ExtValueType
+ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getSumValue(SCCOLROW nPos1, SCCOLROW nPos2)
 {
     RangeData aData;
     if (!getRangeData(nPos1, aData))
@@ -145,8 +145,8 @@ ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getSumValue(SCCOLROW nPos1, SCCOL
     return nValue;
 }
 
-template<typename _ValueType, typename _ExtValueType>
-bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getRangeData(SCCOLROW nPos, RangeData& rData)
+template<typename ValueType_, typename ExtValueType_>
+bool ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getRangeData(SCCOLROW nPos, RangeData& rData)
 {
     if (!mbTreeSearchEnabled)
         return getRangeDataLeaf(nPos, rData);
@@ -161,8 +161,8 @@ bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getRangeData(SCCOLROW nPos,
     return true;
 }
 
-template<typename _ValueType, typename _ExtValueType>
-bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getRangeDataLeaf(SCCOLROW nPos, RangeData& rData)
+template<typename ValueType_, typename ExtValueType_>
+bool ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getRangeDataLeaf(SCCOLROW nPos, RangeData& rData)
 {
     // Conduct leaf-node only search.  Faster when searching between range insertion.
     const ::std::pair<typename fst_type::const_iterator, bool> &ret =
@@ -177,22 +177,22 @@ bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getRangeDataLeaf(SCCOLROW nP
     return true;
 }
 
-template<typename _ValueType, typename _ExtValueType>
-void ScFlatSegmentsImpl<_ValueType, _ExtValueType>::removeSegment(SCCOLROW nPos1, SCCOLROW nPos2)
+template<typename ValueType_, typename ExtValueType_>
+void ScFlatSegmentsImpl<ValueType_, ExtValueType_>::removeSegment(SCCOLROW nPos1, SCCOLROW nPos2)
 {
     maSegments.shift_left(nPos1, nPos2);
     maItr = maSegments.begin();
 }
 
-template<typename _ValueType, typename _ExtValueType>
-void ScFlatSegmentsImpl<_ValueType, _ExtValueType>::insertSegment(SCCOLROW nPos, SCCOLROW nSize, bool bSkipStartBoundary)
+template<typename ValueType_, typename ExtValueType_>
+void ScFlatSegmentsImpl<ValueType_, ExtValueType_>::insertSegment(SCCOLROW nPos, SCCOLROW nSize, bool bSkipStartBoundary)
 {
     maSegments.shift_right(nPos, nSize, bSkipStartBoundary);
     maItr = maSegments.begin();
 }
 
-template<typename _ValueType, typename _ExtValueType>
-SCCOLROW ScFlatSegmentsImpl<_ValueType, _ExtValueType>::findLastTrue(ValueType nValue) const
+template<typename ValueType_, typename ExtValueType_>
+SCCOLROW ScFlatSegmentsImpl<ValueType_, ExtValueType_>::findLastTrue(ValueType nValue) const
 {
     SCCOLROW nPos = numeric_limits<SCCOLROW>::max(); // position not found.
     typename fst_type::const_reverse_iterator itr = maSegments.rbegin(), itrEnd = maSegments.rend();
@@ -209,15 +209,15 @@ SCCOLROW ScFlatSegmentsImpl<_ValueType, _ExtValueType>::findLastTrue(ValueType n
     return nPos;
 }
 
-template<typename _ValueType, typename _ExtValueType>
-bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getFirst(RangeData& rData)
+template<typename ValueType_, typename ExtValueType_>
+bool ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getFirst(RangeData& rData)
 {
     maItr = maSegments.begin();
     return getNext(rData);
 }
 
-template<typename _ValueType, typename _ExtValueType>
-bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getNext(RangeData& rData)
+template<typename ValueType_, typename ExtValueType_>
+bool ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getNext(RangeData& rData)
 {
     typename fst_type::const_iterator itrEnd = maSegments.end();
     if (maItr == itrEnd)
diff --git a/sc/source/core/data/table3.cxx b/sc/source/core/data/table3.cxx
index 4cd6bf28b3a5..3fb4799a002d 100644
--- a/sc/source/core/data/table3.cxx
+++ b/sc/source/core/data/table3.cxx
@@ -652,12 +652,12 @@ void ScTable::DestroySortCollator()
 
 namespace {
 
-template<typename _Hint, typename _ReorderMap, typename _Index>
+template<typename Hint, typename ReorderMap, typename Index>
 class ReorderNotifier : public std::unary_function<SvtListener*, void>
 {
-    _Hint maHint;
+    Hint maHint;
 public:
-    ReorderNotifier( const _ReorderMap& rMap, SCTAB nTab, _Index nPos1, _Index nPos2 ) :
+    ReorderNotifier( const ReorderMap& rMap, SCTAB nTab, Index nPos1, Index nPos2 ) :
         maHint(rMap, nTab, nPos1, nPos2) {}
 
     void operator() ( SvtListener* p )
diff --git a/sc/source/core/tool/interpr5.cxx b/sc/source/core/tool/interpr5.cxx
index 40cca4eb7779..66b20f6cced5 100644
--- a/sc/source/core/tool/interpr5.cxx
+++ b/sc/source/core/tool/interpr5.cxx
@@ -1096,11 +1096,11 @@ static inline SCSIZE lcl_GetMinExtent( SCSIZE n1, SCSIZE n2 )
         return n2;
 }
 
-template<class _Function>
+template<class Function>
 static ScMatrixRef lcl_MatrixCalculation(
     const ScMatrix& rMat1, const ScMatrix& rMat2, ScInterpreter* pInterpreter)
 {
-    static _Function Op;
+    static Function Op;
 
     SCSIZE nC1, nC2, nMinC;
     SCSIZE nR1, nR2, nMinR;
diff --git a/sc/source/core/tool/scmatrix.cxx b/sc/source/core/tool/scmatrix.cxx
index 8c096d442bab..26b98ac54f50 100644
--- a/sc/source/core/tool/scmatrix.cxx
+++ b/sc/source/core/tool/scmatrix.cxx
@@ -131,10 +131,10 @@ struct ElemLessEqualZero : public unary_function<double, double>
     }
 };
 
-template<typename _Comp>
+template<typename Comp>
 class CompareMatrixElemFunc : public std::unary_function<MatrixImplType::element_block_node_type, void>
 {
-    static _Comp maComp;
+    static Comp maComp;
 
     std::vector<double> maNewMatValues;     // double instead of bool to transport error values
     size_t mnRow;
@@ -190,8 +190,8 @@ public:
     }
 };
 
-template<typename _Comp>
-_Comp CompareMatrixElemFunc<_Comp>::maComp;
+template<typename Comp>
+Comp CompareMatrixElemFunc<Comp>::maComp;
 
 }
 
@@ -979,10 +979,10 @@ struct XorEvaluator
 
 // Do not short circuit logical operations, in case there are error values
 // these need to be propagated even if the result was determined earlier.
-template <typename _Evaluator>
+template <typename Evaluator>
 double EvalMatrix(const MatrixImplType& rMat)
 {
-    _Evaluator aEval;
+    Evaluator aEval;
     size_t nRows = rMat.size().row, nCols = rMat.size().column;
     for (size_t i = 0; i < nRows; ++i)
     {
@@ -1030,15 +1030,15 @@ double ScMatrixImpl::Xor() const
 
 namespace {
 
-template<typename _Op>
+template<typename Op>
 class WalkElementBlocks
 {
-    _Op maOp;
+    Op maOp;
     ScMatrix::IterateResult maRes;
     bool mbFirst:1;
     bool mbTextAsZero:1;
 public:
-    WalkElementBlocks(bool bTextAsZero) : maRes(_Op::InitVal, _Op::InitVal, 0), mbFirst(true), mbTextAsZero(bTextAsZero) {}
+    WalkElementBlocks(bool bTextAsZero) : maRes(Op::InitVal, Op::InitVal, 0), mbFirst(true), mbTextAsZero(bTextAsZero) {}
 
     const ScMatrix::IterateResult& getResult() const { return maRes; }
 
@@ -1099,15 +1099,15 @@ public:
     }
 };
 
-template<typename _Op>
+template<typename Op>
 class WalkElementBlocksMultipleValues
 {
-    const std::vector<std::unique_ptr<_Op>>& maOp;
+    const std::vector<std::unique_ptr<Op>>& maOp;
     std::vector<ScMatrix::IterateResult> maRes;
     bool mbFirst:1;
     bool mbTextAsZero:1;
 public:
-    WalkElementBlocksMultipleValues(bool bTextAsZero, const std::vector<std::unique_ptr<_Op>>& aOp) :
+    WalkElementBlocksMultipleValues(bool bTextAsZero, const std::vector<std::unique_ptr<Op>>& aOp) :
         maOp(aOp), mbFirst(true), mbTextAsZero(bTextAsZero)
     {
         for (const auto& pOp : maOp)
@@ -1234,10 +1234,10 @@ public:
 
 const size_t ResultNotSet = std::numeric_limits<size_t>::max();
 
-template<typename _Type>
+template<typename Type>
 class WalkAndMatchElements : public std::unary_function<MatrixImplType::element_block_node_type, void>
 {
-    _Type maMatchValue;
+    Type maMatchValue;
     MatrixImplType::size_pair_type maSize;
     size_t mnCol1;
     size_t mnCol2;
@@ -1245,7 +1245,7 @@ class WalkAndMatchElements : public std::unary_function<MatrixImplType::element_
     size_t mnIndex;
 
 public:
-    WalkAndMatchElements(_Type aMatchValue, const MatrixImplType::size_pair_type& aSize, size_t nCol1, size_t nCol2) :
+    WalkAndMatchElements(Type aMatchValue, const MatrixImplType::size_pair_type& aSize, size_t nCol1, size_t nCol2) :
         maMatchValue(aMatchValue),
         maSize(aSize),
         mnCol1(nCol1),
@@ -1384,7 +1384,7 @@ struct MinOp
     }
 };
 
-template<typename _Op>
+template<typename Op>
 class CalcMaxMinValue : public std::unary_function<MatrixImplType::element_block_type, void>
 {
     double mfVal;
@@ -1392,7 +1392,7 @@ class CalcMaxMinValue : public std::unary_function<MatrixImplType::element_block
     bool mbHasValue;
 public:
     CalcMaxMinValue( bool bTextAsZero ) :
-        mfVal(_Op::init()),
+        mfVal(Op::init()),
         mbTextAsZero(bTextAsZero),
         mbHasValue(false) {}
 
@@ -1410,7 +1410,7 @@ public:
                 block_type::const_iterator it = block_type::begin(*node.data);
                 block_type::const_iterator itEnd = block_type::end(*node.data);
                 for (; it != itEnd; ++it)
-                    mfVal = _Op::compare(mfVal, *it);
+                    mfVal = Op::compare(mfVal, *it);
 
                 mbHasValue = true;
             }
@@ -1421,8 +1421,8 @@ public:
 
                 block_type::const_iterator it = block_type::begin(*node.data);
                 block_type::const_iterator itEnd = block_type::end(*node.data);
-                double fVal = _Op::boolValue(it, itEnd);
-                mfVal = _Op::compare(mfVal, fVal);
+                double fVal = Op::boolValue(it, itEnd);
+                mfVal = Op::compare(mfVal, fVal);
                 mbHasValue = true;
             }
             break;
@@ -1432,7 +1432,7 @@ public:
                 // empty elements are treated as empty strings.
                 if (mbTextAsZero)
                 {
-                    mfVal = _Op::compare(mfVal, 0.0);
+                    mfVal = Op::compare(mfVal, 0.0);
                     mbHasValue = true;
                 }
             }
@@ -1730,7 +1730,7 @@ struct ArrayMul : public std::binary_function<double, double, double>
     }
 };
 
-template<typename _Op>
+template<typename Op>
 class MergeDoubleArrayFunc : public std::unary_function<MatrixImplType::element_block_type, void>
 {
     std::vector<double>& mrArray;
@@ -1745,7 +1745,7 @@ public:
     void operator() (const MatrixImplType::element_block_node_type& node)
     {
         using namespace mdds::mtv;
-        static _Op op;
+        static Op op;
 
         switch (node.type)
         {
diff --git a/sc/source/filter/excel/excform.cxx b/sc/source/filter/excel/excform.cxx
index 33ec52fbfb5a..fed5b0e5e744 100644
--- a/sc/source/filter/excel/excform.cxx
+++ b/sc/source/filter/excel/excform.cxx
@@ -923,7 +923,7 @@ ConvErr ExcelToSc::Convert( const ScTokenArray*& pErgebnis, XclImpStream& aIn, s
 }
 
 // stream seeks to first byte after <nFormulaLen>
-ConvErr ExcelToSc::Convert( _ScRangeListTabs& rRangeList, XclImpStream& aIn, sal_Size nFormulaLen,
+ConvErr ExcelToSc::Convert( ScRangeListTabs& rRangeList, XclImpStream& aIn, sal_Size nFormulaLen,
                             SCsTAB nTab, const FORMULA_TYPE eFT )
 {
     RootData&       rR = GetOldRoot();
diff --git a/sc/source/filter/excel/excform8.cxx b/sc/source/filter/excel/excform8.cxx
index 5e439159b896..bea8ba395a8c 100644
--- a/sc/source/filter/excel/excform8.cxx
+++ b/sc/source/filter/excel/excform8.cxx
@@ -953,7 +953,7 @@ ConvErr ExcelToSc8::Convert( const ScTokenArray*& rpTokArray, XclImpStream& aIn,
 }
 
 // stream seeks to first byte after <nFormulaLen>
-ConvErr ExcelToSc8::Convert( _ScRangeListTabs& rRangeList, XclImpStream& aIn, sal_Size nFormulaLen,
+ConvErr ExcelToSc8::Convert( ScRangeListTabs& rRangeList, XclImpStream& aIn, sal_Size nFormulaLen,
                               SCsTAB nTab, const FORMULA_TYPE eFT )
 {
     sal_uInt8                   nOp, nLen;
diff --git a/sc/source/filter/excel/exctools.cxx b/sc/source/filter/excel/exctools.cxx
index 1849c4a897a6..0b3fe117e1b0 100644
--- a/sc/source/filter/excel/exctools.cxx
+++ b/sc/source/filter/excel/exctools.cxx
@@ -55,8 +55,8 @@ RootData::RootData()
     pFmlaConverter = nullptr;
 
     pAutoFilterBuffer = nullptr;
-    pPrintRanges = new _ScRangeListTabs;
-    pPrintTitles = new _ScRangeListTabs;
+    pPrintRanges = new ScRangeListTabs;
+    pPrintTitles = new ScRangeListTabs;
 
     pTabId = nullptr;
     pUserBViewList = nullptr;
diff --git a/sc/source/filter/excel/frmbase.cxx b/sc/source/filter/excel/frmbase.cxx
index fd1c4d778100..16ec427d0180 100644
--- a/sc/source/filter/excel/frmbase.cxx
+++ b/sc/source/filter/excel/frmbase.cxx
@@ -21,15 +21,15 @@
 
 #include <o3tl/make_unique.hxx>
 
-_ScRangeListTabs::_ScRangeListTabs()
+ScRangeListTabs::ScRangeListTabs()
 {
 }
 
-_ScRangeListTabs::~_ScRangeListTabs()
+ScRangeListTabs::~ScRangeListTabs()
 {
 }
 
-void _ScRangeListTabs::Append( const ScAddress& aSRD, SCTAB nTab )
+void ScRangeListTabs::Append( const ScAddress& aSRD, SCTAB nTab )
 {
     ScAddress a = aSRD;
 
@@ -66,7 +66,7 @@ void _ScRangeListTabs::Append( const ScAddress& aSRD, SCTAB nTab )
     itr->second->push_back(ScRange(a.Col(),a.Row(),a.Tab()));
 }
 
-void _ScRangeListTabs::Append( const ScRange& aCRD, SCTAB nTab )
+void ScRangeListTabs::Append( const ScRange& aCRD, SCTAB nTab )
 {
     ScRange a = aCRD;
 
@@ -124,9 +124,9 @@ void _ScRangeListTabs::Append( const ScRange& aCRD, SCTAB nTab )
     itr->second->push_back(a);
 }
 
-const ScRange* _ScRangeListTabs::First( SCTAB n )
+const ScRange* ScRangeListTabs::First( SCTAB n )
 {
-    OSL_ENSURE( ValidTab(n), "-_ScRangeListTabs::First(): Good bye!" );
+    OSL_ENSURE( ValidTab(n), "-ScRangeListTabs::First(): Good bye!" );
 
     TabRangeType::iterator itr = m_TabRanges.find(n);
     if (itr == m_TabRanges.end())
@@ -139,7 +139,7 @@ const ScRange* _ScRangeListTabs::First( SCTAB n )
     return rList.empty() ? nullptr : &(*maItrCur);
 }
 
-const ScRange* _ScRangeListTabs::Next ()
+const ScRange* ScRangeListTabs::Next ()
 {
     ++maItrCur;
     if (maItrCur == maItrCurEnd)
diff --git a/sc/source/filter/excel/xiroot.cxx b/sc/source/filter/excel/xiroot.cxx
index 2ff388b8a26c..23cfb0b3c4fd 100644
--- a/sc/source/filter/excel/xiroot.cxx
+++ b/sc/source/filter/excel/xiroot.cxx
@@ -169,13 +169,13 @@ XclImpXFRangeBuffer& XclImpRoot::GetXFRangeBuffer() const
     return *mrImpData.mxXFRangeBfr;
 }
 
-_ScRangeListTabs& XclImpRoot::GetPrintAreaBuffer() const
+ScRangeListTabs& XclImpRoot::GetPrintAreaBuffer() const
 {
     // TODO still in old RootData
     return *GetOldRoot().pPrintRanges;
 }
 
-_ScRangeListTabs& XclImpRoot::GetTitleAreaBuffer() const
+ScRangeListTabs& XclImpRoot::GetTitleAreaBuffer() const
 {
     // TODO still in old RootData
     return *GetOldRoot().pPrintTitles;
diff --git a/sc/source/filter/inc/excform.hxx b/sc/source/filter/inc/excform.hxx
index ebc6db0d8f0e..5edda9f767c4 100644
--- a/sc/source/filter/inc/excform.hxx
+++ b/sc/source/filter/inc/excform.hxx
@@ -51,7 +51,7 @@ public:
     virtual ConvErr     Convert( const ScTokenArray*&, XclImpStream& rStrm, sal_Size nFormulaLen,
                                  bool bAllowArrays, const FORMULA_TYPE eFT = FT_CellFormula ) override;
 
-    virtual ConvErr     Convert( _ScRangeListTabs&, XclImpStream& rStrm, sal_Size nFormulaLen, SCsTAB nTab, const FORMULA_TYPE eFT = FT_CellFormula ) override;
+    virtual ConvErr     Convert( ScRangeListTabs&, XclImpStream& rStrm, sal_Size nFormulaLen, SCsTAB nTab, const FORMULA_TYPE eFT = FT_CellFormula ) override;
 
     virtual void        ConvertExternName( const ScTokenArray*& rpArray, XclImpStream& rStrm, sal_Size nFormulaLen,
                                            const OUString& rUrl, const ::std::vector<OUString>& rTabNames );
@@ -124,7 +124,7 @@ public:
 
     virtual ConvErr     Convert( const ScTokenArray*& rpTokArray, XclImpStream& rStrm, sal_Size nFormulaLen, bool bAllowArrays, const FORMULA_TYPE eFT = FT_CellFormula ) override;
 
-    virtual ConvErr     Convert( _ScRangeListTabs&, XclImpStream& rStrm, sal_Size nFormulaLen, SCsTAB nTab, const FORMULA_TYPE eFT = FT_CellFormula ) override;
+    virtual ConvErr     Convert( ScRangeListTabs&, XclImpStream& rStrm, sal_Size nFormulaLen, SCsTAB nTab, const FORMULA_TYPE eFT = FT_CellFormula ) override;
 
     virtual void        ConvertExternName( const ScTokenArray*& rpArray, XclImpStream& rStrm, sal_Size nFormulaLen,
                                            const OUString& rUrl, const ::std::vector<OUString>& rTabNames ) override;
diff --git a/sc/source/filter/inc/formel.hxx b/sc/source/filter/inc/formel.hxx
index 2faca173d489..8a5815176027 100644
--- a/sc/source/filter/inc/formel.hxx
+++ b/sc/source/filter/inc/formel.hxx
@@ -58,7 +58,7 @@ enum FORMULA_TYPE
     FT_CondFormat
 };
 
-class _ScRangeListTabs
+class ScRangeListTabs
 {
     typedef ::std::vector<ScRange> RangeListType;
     typedef ::std::map<SCTAB, std::unique_ptr<RangeListType>> TabRangeType;
@@ -67,8 +67,8 @@ class _ScRangeListTabs
     RangeListType::const_iterator maItrCurEnd;
 
 public:
-    _ScRangeListTabs ();
-    ~_ScRangeListTabs();
+    ScRangeListTabs ();
+    ~ScRangeListTabs();
 
     void Append( const ScAddress& aSRD, SCTAB nTab );
     void Append( const ScRange& aCRD, SCTAB nTab );
@@ -106,7 +106,7 @@ public:
 
     virtual ConvErr     Convert( const ScTokenArray*& rpErg, XclImpStream& rStrm, sal_Size nFormulaLen,
                                  bool bAllowArrays, const FORMULA_TYPE eFT = FT_CellFormula ) = 0;
-    virtual ConvErr     Convert( _ScRangeListTabs&, XclImpStream& rStrm, sal_Size nFormulaLen, SCsTAB nTab,
+    virtual ConvErr     Convert( ScRangeListTabs&, XclImpStream& rStrm, sal_Size nFormulaLen, SCsTAB nTab,
                                     const FORMULA_TYPE eFT = FT_CellFormula ) = 0;
 };
 
diff --git a/sc/source/filter/inc/lotimpop.hxx b/sc/source/filter/inc/lotimpop.hxx
index 0cae6aa8b31d..4d9fe6f38e5a 100644
--- a/sc/source/filter/inc/lotimpop.hxx
+++ b/sc/source/filter/inc/lotimpop.hxx
@@ -60,7 +60,7 @@ private:
     void                Font_Face();                  // 174
     void                Font_Type();                  // 176
     void                Font_Ysize();                 // 177
-    void                _Row( const sal_uInt16 nRecLen );       // 197 ?
+    void                Row_( const sal_uInt16 nRecLen );       // 197 ?
 
     inline void         Read( ScAddress& );
     inline void         Read( ScRange& );
diff --git a/sc/source/filter/inc/root.hxx b/sc/source/filter/inc/root.hxx
index f92b2fd3e132..c44088ea7680 100644
--- a/sc/source/filter/inc/root.hxx
+++ b/sc/source/filter/inc/root.hxx
@@ -36,7 +36,7 @@ class ExcelToSc;
 
 class XclImpColRowSettings;
 class XclImpAutoFilterBuffer;
-class _ScRangeListTabs;
+class ScRangeListTabs;
 
 class XclExpChTrTabId;
 class XclExpUserBViewList;
@@ -57,8 +57,8 @@ struct RootData     // -> Inkarnation jeweils im ImportExcel-Objekt!
 
     // Biff8
     XclImpAutoFilterBuffer* pAutoFilterBuffer;      // ranges for autofilter and advanced filter
-    _ScRangeListTabs*       pPrintRanges;
-    _ScRangeListTabs*       pPrintTitles;
+    ScRangeListTabs*       pPrintRanges;
+    ScRangeListTabs*       pPrintTitles;
 
     // Erweiterungen fuer Export
     XclExpChTrTabId*        pTabId;             // pointer to rec list, do not destroy
diff --git a/sc/source/filter/inc/xiroot.hxx b/sc/source/filter/inc/xiroot.hxx
index 099d885ebfeb..ca469a43f640 100644
--- a/sc/source/filter/inc/xiroot.hxx
+++ b/sc/source/filter/inc/xiroot.hxx
@@ -56,7 +56,7 @@ class XclImpTabViewSettings;
 class XclImpSheetProtectBuffer;
 class XclImpDocProtectBuffer;
 
-class _ScRangeListTabs;
+class ScRangeListTabs;
 class ExcelToSc;
 class ScDocumentImport;
 
@@ -163,9 +163,9 @@ public:
     XclImpXFRangeBuffer& GetXFRangeBuffer() const;
 
     /** Returns the buffer that contains all print areas in the document. */
-    _ScRangeListTabs&   GetPrintAreaBuffer() const;
+    ScRangeListTabs&   GetPrintAreaBuffer() const;
     /** Returns the buffer that contains all print titles in the document. */
-    _ScRangeListTabs&   GetTitleAreaBuffer() const;
+    ScRangeListTabs&   GetTitleAreaBuffer() const;
 
     /** Returns the buffer that contains the sheet creation order. */
     XclImpTabInfo&      GetTabInfo() const;
diff --git a/sc/source/filter/lotus/lotimpop.cxx b/sc/source/filter/lotus/lotimpop.cxx
index 586ca37f6bac..fa937c510021 100644
--- a/sc/source/filter/lotus/lotimpop.cxx
+++ b/sc/source/filter/lotus/lotimpop.cxx
@@ -379,9 +379,9 @@ void ImportLotus::Font_Ysize()
     }
 }
 
-void ImportLotus::_Row( const sal_uInt16 nRecLen )
+void ImportLotus::Row_( const sal_uInt16 nRecLen )
 {
-    OSL_ENSURE( nExtTab >= 0, "*ImportLotus::_Row(): not possible!" );
+    OSL_ENSURE( nExtTab >= 0, "*ImportLotus::Row_(): not possible!" );
 
     sal_uInt16            nCntDwn = (nRecLen < 4) ? 0 : ( nRecLen - 4 ) / 5;
     SCCOL           nColCnt = 0;
diff --git a/sc/source/filter/lotus/lotread.cxx b/sc/source/filter/lotus/lotread.cxx
index 58c5e18609ed..5e30fb56ad09 100644
--- a/sc/source/filter/lotus/lotread.cxx
+++ b/sc/source/filter/lotus/lotread.cxx
@@ -289,7 +289,7 @@ FltError ImportLotus::Read(SvStream& rIn)
                     nExtTab++;
                     break;
                 case 197:
-                    _Row( nRecLen );
+                    Row_( nRecLen );
                 break;
             }
 
diff --git a/sc/source/ui/unoobj/shapeuno.cxx b/sc/source/ui/unoobj/shapeuno.cxx
index 3a363a557c04..d7d39282797f 100644
--- a/sc/source/ui/unoobj/shapeuno.cxx
+++ b/sc/source/ui/unoobj/shapeuno.cxx
@@ -1472,9 +1472,9 @@ OUString SAL_CALL ScShapeObj::getImplementationName(  ) throw (uno::RuntimeExcep
     return OUString( "com.sun.star.comp.sc.ScShapeObj" );
 }
 
-sal_Bool SAL_CALL ScShapeObj::supportsService( const OUString& _ServiceName ) throw (uno::RuntimeException, std::exception)
+sal_Bool SAL_CALL ScShapeObj::supportsService( const OUString& ServiceName ) throw (uno::RuntimeException, std::exception)
 {
-    return cppu::supportsService(this, _ServiceName);
+    return cppu::supportsService(this, ServiceName);
 }
 
 uno::Sequence< OUString > SAL_CALL ScShapeObj::getSupportedServiceNames(  ) throw (uno::RuntimeException, std::exception)
diff --git a/sc/source/ui/unoobj/viewuno.cxx b/sc/source/ui/unoobj/viewuno.cxx
index 3d0aaa4d2950..3725b8240b31 100644
--- a/sc/source/ui/unoobj/viewuno.cxx
+++ b/sc/source/ui/unoobj/viewuno.cxx
@@ -318,7 +318,7 @@ namespace
 }
 
 // XFormLayerAccess
-uno::Reference< form::runtime::XFormController > SAL_CALL ScViewPaneBase::getFormController( const uno::Reference< form::XForm >& _Form ) throw (uno::RuntimeException, std::exception)
+uno::Reference< form::runtime::XFormController > SAL_CALL ScViewPaneBase::getFormController( const uno::Reference< form::XForm >& Form ) throw (uno::RuntimeException, std::exception)
 {
     SolarMutexGuard aGuard;
 
@@ -328,7 +328,7 @@ uno::Reference< form::runtime::XFormController > SAL_CALL ScViewPaneBase::getFor
     SdrView* pSdrView( nullptr );
     FmFormShell* pFormShell( nullptr );
     if ( lcl_prepareFormShellCall( pViewShell, nPane, pFormShell, pWindow, pSdrView ) )
-        xController = FmFormShell::GetFormController( _Form, *pSdrView, *pWindow );
+        xController = FmFormShell::GetFormController( Form, *pSdrView, *pWindow );
 
     return xController;
 }
@@ -346,7 +346,7 @@ sal_Bool SAL_CALL ScViewPaneBase::isFormDesignMode(  ) throw (uno::RuntimeExcept
     return bIsFormDesignMode;
 }
 
-void SAL_CALL ScViewPaneBase::setFormDesignMode( sal_Bool _DesignMode ) throw (uno::RuntimeException, std::exception)
+void SAL_CALL ScViewPaneBase::setFormDesignMode( sal_Bool DesignMode ) throw (uno::RuntimeException, std::exception)
 {
     SolarMutexGuard aGuard;
 
@@ -354,7 +354,7 @@ void SAL_CALL ScViewPaneBase::setFormDesignMode( sal_Bool _DesignMode ) throw (u
     SdrView* pSdrView( nullptr );
     FmFormShell* pFormShell( nullptr );
     if ( lcl_prepareFormShellCall( pViewShell, nPane, pFormShell, pWindow, pSdrView ) )
-        pFormShell->SetDesignMode( _DesignMode );
+        pFormShell->SetDesignMode( DesignMode );
 }
 
 // XControlAccess
diff --git a/sc/source/ui/vba/vbaformat.hxx b/sc/source/ui/vba/vbaformat.hxx
index c7b14aa21f49..b02bd6965bf6 100644
--- a/sc/source/ui/vba/vbaformat.hxx
+++ b/sc/source/ui/vba/vbaformat.hxx
@@ -57,7 +57,7 @@ public:
     ScVbaFormat( const css::uno::Reference< ov::XHelperInterface >& xParent, const css::uno::Reference< css::uno::XComponentContext > & xContext, const css::uno::Reference< css::beans::XPropertySet >& _xPropertySet, const css::uno::Reference< css::frame::XModel >& xModel, bool bCheckAmbiguoity ) throw ( css::script::BasicErrorException );
     virtual ~ScVbaFormat() {}
     virtual css::uno::Reference< ov::XHelperInterface > thisHelperIface() = 0;
-     void SAL_CALL setAddIndent( const css::uno::Any& _BAddIndent) throw( css::uno::RuntimeException ) { _BAddIndent >>= mbAddIndent; }
+     void SAL_CALL setAddIndent( const css::uno::Any& BAddIndent) throw( css::uno::RuntimeException ) { BAddIndent >>= mbAddIndent; }
      css::uno::Any SAL_CALL getAddIndent() throw( css::uno::RuntimeException ) { return css::uno::makeAny( mbAddIndent ); }
         // Interface Methods
     virtual css::uno::Any SAL_CALL Borders( const css::uno::Any& Index ) throw (css::script::BasicErrorException, css::uno::RuntimeException);
diff --git a/sc/source/ui/view/output2.cxx b/sc/source/ui/view/output2.cxx
index 75d60d988a7d..d110c1d48dd8 100644
--- a/sc/source/ui/view/output2.cxx
+++ b/sc/source/ui/view/output2.cxx
@@ -264,11 +264,11 @@ void ScDrawStringsVars::SetShrinkScale( long nScale, SvtScriptType nScript )
 
 namespace {
 
-template<typename _ItemType, typename _EnumType>
-_EnumType lcl_GetValue(const ScPatternAttr& rPattern, sal_uInt16 nWhich, const SfxItemSet* pCondSet)
+template<typename ItemType, typename EnumType>
+EnumType lcl_GetValue(const ScPatternAttr& rPattern, sal_uInt16 nWhich, const SfxItemSet* pCondSet)
 {
-    const _ItemType& rItem = static_cast<const _ItemType&>(rPattern.GetItem(nWhich, pCondSet));
-    return static_cast<_EnumType>(rItem.GetValue());
+    const ItemType& rItem = static_cast<const ItemType&>(rPattern.GetItem(nWhich, pCondSet));
+    return static_cast<EnumType>(rItem.GetValue());
 }
 
 bool lcl_GetBoolValue(const ScPatternAttr& rPattern, sal_uInt16 nWhich, const SfxItemSet* pCondSet)