replace sal_Size with std::size_t (or sal_uInt64 for SvStream pos)

... except in include/rtl, include/sal, include/uno, where sal_Size is
retained for compatibility, and where callers of rtl functions pass in
pointers that are incompatible on MSVC.

Change-Id: I8344453780689f5120ba0870e44965b6d292450c

22 files changed, 92 insertions, 92 deletions

diff --git a/vcl/inc/unx/i18n_ic.hxx b/vcl/inc/unx/i18n_ic.hxx
index ee963406338a..037680cbc21e 100644
--- a/vcl/inc/unx/i18n_ic.hxx
+++ b/vcl/inc/unx/i18n_ic.hxx
@@ -67,7 +67,7 @@ public:
     void HandleDestroyIM();
 
     void EndExtTextInput( EndExtTextInputFlags nFlags );        // unused
-    void  CommitKeyEvent( sal_Unicode* pText, sal_Size nLength );
+    void  CommitKeyEvent( sal_Unicode* pText, std::size_t nLength );
     int  UpdateSpotLocation();
 
     void Map( SalFrame *pFrame );
diff --git a/vcl/qa/cppunit/canvasbitmaptest.cxx b/vcl/qa/cppunit/canvasbitmaptest.cxx
index 8076d2b0384b..7198b097ebc1 100644
--- a/vcl/qa/cppunit/canvasbitmaptest.cxx
+++ b/vcl/qa/cppunit/canvasbitmaptest.cxx
@@ -522,10 +522,10 @@ private:
                                                                                                                                        uno::RuntimeException, std::exception) override
     {
         const uno::Sequence< rendering::ARGBColor > aTemp( convertIntegerToARGB(deviceColor) );
-        const sal_Size nLen(aTemp.getLength());
+        const std::size_t nLen(aTemp.getLength());
         uno::Sequence< rendering::RGBColor > aRes( nLen );
         rendering::RGBColor* pOut = aRes.getArray();
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             *pOut++ = rendering::RGBColor(aTemp[i].Red,
                                           aTemp[i].Green,
@@ -538,7 +538,7 @@ private:
     virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,
                                                                                                                                          uno::RuntimeException, std::exception) override
     {
-        const sal_Size  nLen( deviceColor.getLength() );
+        const std::size_t  nLen( deviceColor.getLength() );
         const sal_Int32 nBytesPerPixel(mnBitsPerPixel == 8 ? 1 : 4);
         CPPUNIT_ASSERT_MESSAGE("number of channels no multiple of pixel element count",
                                nLen%nBytesPerPixel==0);
@@ -548,7 +548,7 @@ private:
 
         if( getPalette().is() )
         {
-            for( sal_Size i=0; i<nLen; ++i )
+            for( std::size_t i=0; i<nLen; ++i )
             {
                 *pOut++ = rendering::ARGBColor(
                     1.0,
@@ -559,7 +559,7 @@ private:
         }
         else
         {
-            for( sal_Size i=0; i<nLen; i+=4 )
+            for( std::size_t i=0; i<nLen; i+=4 )
             {
                 *pOut++ = rendering::ARGBColor(
                     vcl::unotools::toDoubleColor(deviceColor[i+3]),
@@ -578,7 +578,7 @@ private:
                    uno::RuntimeException,
                    std::exception) override
     {
-        const sal_Size  nLen( deviceColor.getLength() );
+        const std::size_t  nLen( deviceColor.getLength() );
         const sal_Int32 nBytesPerPixel(mnBitsPerPixel == 8 ? 1 : 4);
         CPPUNIT_ASSERT_MESSAGE("number of channels no multiple of pixel element count",
                                nLen%nBytesPerPixel==0);
@@ -588,7 +588,7 @@ private:
 
         if( getPalette().is() )
         {
-            for( sal_Size i=0; i<nLen; ++i )
+            for( std::size_t i=0; i<nLen; ++i )
             {
                 *pOut++ = rendering::ARGBColor(
                     1.0,
@@ -599,7 +599,7 @@ private:
         }
         else
         {
-            for( sal_Size i=0; i<nLen; i+=4 )
+            for( std::size_t i=0; i<nLen; i+=4 )
             {
                 const double fAlpha=vcl::unotools::toDoubleColor(deviceColor[i+3]);
                 *pOut++ = rendering::ARGBColor(
diff --git a/vcl/source/bitmap/BitmapTools.cxx b/vcl/source/bitmap/BitmapTools.cxx
index 98aef88379e4..f50cca876ee9 100644
--- a/vcl/source/bitmap/BitmapTools.cxx
+++ b/vcl/source/bitmap/BitmapTools.cxx
@@ -34,7 +34,7 @@ void BitmapTools::loadFromSvg(SvStream& rStream, const OUString& sPath, BitmapEx
     uno::Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext());
     const uno::Reference<graphic::XSvgParser> xSvgParser = graphic::SvgTools::create(xContext);
 
-    sal_Size nSize = rStream.remainingSize();
+    std::size_t nSize = rStream.remainingSize();
     std::vector<sal_Int8> aBuffer(nSize + 1);
     rStream.ReadBytes(aBuffer.data(), nSize);
     aBuffer[nSize] = 0;
diff --git a/vcl/source/filter/graphicfilter2.cxx b/vcl/source/filter/graphicfilter2.cxx
index b31c0cb58fc0..4e57a0172980 100644
--- a/vcl/source/filter/graphicfilter2.cxx
+++ b/vcl/source/filter/graphicfilter2.cxx
@@ -948,8 +948,8 @@ bool GraphicDescriptor::ImpDetectPCT( SvStream& rStm, bool )
         nFormat = GraphicFileFormat::PCT;
     else
     {
-        sal_Size nStreamPos = rStm.Tell();
-        sal_Size nStreamLen = rStm.remainingSize();
+        sal_uInt64 const nStreamPos = rStm.Tell();
+        sal_uInt64 const nStreamLen = rStm.remainingSize();
         if (isPCT(rStm, nStreamPos, nStreamLen))
         {
             bRet = true;
diff --git a/vcl/source/filter/igif/gifread.cxx b/vcl/source/filter/igif/gifread.cxx
index 4f7fe836e23f..7b9ac2ab799c 100644
--- a/vcl/source/filter/igif/gifread.cxx
+++ b/vcl/source/filter/igif/gifread.cxx
@@ -270,7 +270,7 @@ void GIFReader::ReadPaletteEntries( BitmapPalette* pPal, sal_uLong nCount )
     if (nLen > nMaxPossible)
         nLen = nMaxPossible;
     std::unique_ptr<sal_uInt8[]> pBuf(new sal_uInt8[ nLen ]);
-    sal_Size nRead = rIStm.ReadBytes(pBuf.get(), nLen);
+    std::size_t nRead = rIStm.ReadBytes(pBuf.get(), nLen);
     nCount = nRead/3UL;
     if( NO_PENDING( rIStm ) )
     {
@@ -417,7 +417,7 @@ bool GIFReader::ReadExtension()
                 std::unique_ptr<sal_uInt8[]> pBuffer(new sal_uInt8[nCount]);
 
                 bRet = false;
-                sal_Size nRead = rIStm.ReadBytes(pBuffer.get(), nCount);
+                std::size_t nRead = rIStm.ReadBytes(pBuffer.get(), nCount);
                 if (NO_PENDING(rIStm) && cSize < nRead)
                 {
                     cSize = pBuffer[cSize];
@@ -437,7 +437,7 @@ bool GIFReader::ReadLocalHeader()
     sal_uInt8   pBuf[ 9 ];
     bool    bRet = false;
 
-    sal_Size nRead = rIStm.ReadBytes(pBuf, 9);
+    std::size_t nRead = rIStm.ReadBytes(pBuf, 9);
     if (NO_PENDING(rIStm) && nRead == 9)
     {
         SvMemoryStream  aMemStm;
diff --git a/vcl/source/filter/wmf/enhwmf.cxx b/vcl/source/filter/wmf/enhwmf.cxx
index 9b3a42a8b47e..05b4f79431ed 100644
--- a/vcl/source/filter/wmf/enhwmf.cxx
+++ b/vcl/source/filter/wmf/enhwmf.cxx
@@ -418,7 +418,7 @@ void EnhWMFReader::ReadEMFPlusComment(sal_uInt32 length, bool& bHaveDC)
 
 #if OSL_DEBUG_LEVEL > 1
         // debug code - write the stream to debug file /tmp/emf-stream.emf
-        int pos = pWMF->Tell();
+        sal_uInt64 const pos = pWMF->Tell();
         pWMF->Seek(0);
         SvFileStream file( OUString( "/tmp/emf-stream.emf" ), StreamMode::WRITE | StreamMode::TRUNC );
 
@@ -432,7 +432,7 @@ void EnhWMFReader::ReadEMFPlusComment(sal_uInt32 length, bool& bHaveDC)
     }
     bEMFPlus = true;
 
-    sal_Size pos = pWMF->Tell();
+    sal_uInt64 const pos = pWMF->Tell();
     void *buffer = malloc( length );
     pOut->PassEMFPlus( buffer, pWMF->ReadBytes(buffer, length) );
     free( buffer );
diff --git a/vcl/source/filter/wmf/winwmf.cxx b/vcl/source/filter/wmf/winwmf.cxx
index e66f3ed8d8a0..bb56e7c91ed5 100644
--- a/vcl/source/filter/wmf/winwmf.cxx
+++ b/vcl/source/filter/wmf/winwmf.cxx
@@ -1156,7 +1156,7 @@ static const long   aMaxWidth = 1024;
 
 bool WMFReader::ReadHeader()
 {
-    sal_Size nStrmPos = pWMF->Tell();
+    sal_uInt64 const nStrmPos = pWMF->Tell();
 
     sal_uInt32 nPlaceableMetaKey(0);
     // if available read the METAFILEHEADER
diff --git a/vcl/source/filter/wmf/wmfwr.cxx b/vcl/source/filter/wmf/wmfwr.cxx
index dfdb36e21e1d..7973b4368be1 100644
--- a/vcl/source/filter/wmf/wmfwr.cxx
+++ b/vcl/source/filter/wmf/wmfwr.cxx
@@ -1836,7 +1836,7 @@ void WMFWriter::WriteEmbeddedEMF( const GDIMetaFile& rMTF )
 
     if( aEMFWriter.WriteEMF( rMTF ) )
     {
-        sal_Size nTotalSize = aStream.Tell();
+        sal_uInt64 const nTotalSize = aStream.Tell();
         if( nTotalSize > SAL_MAX_UINT32 )
             return;
         aStream.Seek( 0 );
diff --git a/vcl/source/gdi/dibtools.cxx b/vcl/source/gdi/dibtools.cxx
index 8814965eee89..d12559b1240c 100644
--- a/vcl/source/gdi/dibtools.cxx
+++ b/vcl/source/gdi/dibtools.cxx
@@ -159,7 +159,7 @@ inline bool isBitfieldCompression( ScanlineFormat nScanlineFormat )
 bool ImplReadDIBInfoHeader(SvStream& rIStm, DIBV5Header& rHeader, bool& bTopDown, bool bMSOFormat)
 {
     // BITMAPINFOHEADER or BITMAPCOREHEADER or BITMAPV5HEADER
-    const sal_Size aStartPos(rIStm.Tell());
+    sal_uInt64 const aStartPos(rIStm.Tell());
     rIStm.ReadUInt32( rHeader.nSize );
 
     // BITMAPCOREHEADER
@@ -198,7 +198,7 @@ bool ImplReadDIBInfoHeader(SvStream& rIStm, DIBV5Header& rHeader, bool& bTopDown
     else
     {
         // BITMAPCOREHEADER, BITMAPV5HEADER or unknown. Read as far as possible
-        sal_Size nUsed(sizeof(rHeader.nSize));
+        std::size_t nUsed(sizeof(rHeader.nSize));
 
         auto readUInt16 = [&nUsed, &rHeader, &rIStm](sal_uInt16 & v) {
             if (nUsed < rHeader.nSize) {
@@ -514,11 +514,11 @@ bool ImplReadDIBBits(SvStream& rIStm, DIBV5Header& rHeader, BitmapWriteAccess& r
     if (bNative)
     {
         if (nAlignedWidth
-            > std::numeric_limits<sal_Size>::max() / rHeader.nHeight)
+            > std::numeric_limits<std::size_t>::max() / rHeader.nHeight)
         {
             return false;
         }
-        sal_Size n = nAlignedWidth * rHeader.nHeight;
+        std::size_t n = nAlignedWidth * rHeader.nHeight;
         if (rIStm.ReadBytes(rAcc.GetBuffer(), n) != n)
         {
             return false;
diff --git a/vcl/source/gdi/gfxlink.cxx b/vcl/source/gdi/gfxlink.cxx
index cddf455af34a..4fdd0e1398e9 100644
--- a/vcl/source/gdi/gfxlink.cxx
+++ b/vcl/source/gdi/gfxlink.cxx
@@ -269,7 +269,7 @@ std::shared_ptr<sal_uInt8> GfxLink::GetSwapInData() const
         pData = o3tl::make_shared_array<sal_uInt8>(mnSwapInDataSize);
         xIStm->ReadBytes( pData.get(), mnSwapInDataSize );
         bool bError = ( ERRCODE_NONE != xIStm->GetError() );
-        sal_Size nActReadSize = xIStm->Tell();
+        sal_uInt64 const nActReadSize = xIStm->Tell();
         if (nActReadSize != mnSwapInDataSize)
         {
             bError = true;
diff --git a/vcl/source/gdi/jobset.cxx b/vcl/source/gdi/jobset.cxx
index 22de45135d15..f80e246a5c68 100644
--- a/vcl/source/gdi/jobset.cxx
+++ b/vcl/source/gdi/jobset.cxx
@@ -246,7 +246,7 @@ SvStream& ReadJobSetup( SvStream& rIStream, JobSetup& rJobSetup )
                      " max possible entries, but " << nRead << " claimed, truncating");
             return rIStream;
         }
-        sal_Size nFirstPos = rIStream.Tell();
+        sal_uInt64 const nFirstPos = rIStream.Tell();
         std::unique_ptr<char[]> pTempBuf(new char[nRead]);
         rIStream.ReadBytes(pTempBuf.get(), nRead);
         if (nRead >= sizeof(ImplOldJobSetupData))
diff --git a/vcl/source/gdi/pdfwriter_impl.cxx b/vcl/source/gdi/pdfwriter_impl.cxx
index d05762cfdeb6..251672cc56aa 100644
--- a/vcl/source/gdi/pdfwriter_impl.cxx
+++ b/vcl/source/gdi/pdfwriter_impl.cxx
@@ -2153,7 +2153,7 @@ bool PDFWriterImpl::writeBuffer( const void* pBuffer, sal_uInt64 nBytes )
     {
         m_aOutputStreams.front().m_pStream->Seek( STREAM_SEEK_TO_END );
         m_aOutputStreams.front().m_pStream->WriteBytes(
-                pBuffer, sal::static_int_cast<sal_Size>(nBytes));
+                pBuffer, sal::static_int_cast<std::size_t>(nBytes));
         return true;
     }
 
@@ -2819,7 +2819,7 @@ bool PDFWriterImpl::emitTilings()
 
         bool bDeflate = compressStream( it->m_pTilingStream );
         it->m_pTilingStream->Seek( STREAM_SEEK_TO_END );
-        sal_Size nTilingStreamSize = it->m_pTilingStream->Tell();
+        sal_uInt64 const nTilingStreamSize = it->m_pTilingStream->Tell();
         it->m_pTilingStream->Seek( STREAM_SEEK_TO_BEGIN );
 
         // write pattern object
diff --git a/vcl/source/gdi/pngread.cxx b/vcl/source/gdi/pngread.cxx
index 9e4fcb58adc4..00497a337b0a 100644
--- a/vcl/source/gdi/pngread.cxx
+++ b/vcl/source/gdi/pngread.cxx
@@ -85,7 +85,7 @@ private:
     sal_uInt8*          mpTransTab;     // for transparency in images with palette colortype
     sal_uInt8*          mpScanCurrent;  // pointer into the current scanline
     sal_uInt8*          mpColorTable;
-    sal_Size            mnStreamSize;   // estimate of PNG file size
+    std::size_t         mnStreamSize;   // estimate of PNG file size
     sal_uInt32          mnChunkType;    // Type of current PNG chunk
     sal_Int32           mnChunkLen;     // Length of current PNG chunk
     Size                maOrigSize;     // pixel size of the full image
@@ -220,7 +220,7 @@ PNGReaderImpl::PNGReaderImpl( SvStream& rPNGStream )
     maChunkIter = maChunkSeq.begin();
 
     // estimate PNG file size (to allow sanity checks)
-    const sal_Size nStreamPos = mrPNGStream.Tell();
+    const std::size_t nStreamPos = mrPNGStream.Tell();
     mrPNGStream.Seek( STREAM_SEEK_TO_END );
     mnStreamSize = mrPNGStream.Tell();
     mrPNGStream.Seek( nStreamPos );
@@ -278,7 +278,7 @@ bool PNGReaderImpl::ReadNextChunk()
         rChunkData.nType = mnChunkType;
 
         // fdo#61847 truncate over-long, trailing chunks
-        const sal_Size nStreamPos = mrPNGStream.Tell();
+        const std::size_t nStreamPos = mrPNGStream.Tell();
         if( mnChunkLen < 0 || nStreamPos + mnChunkLen >= mnStreamSize )
             mnChunkLen = mnStreamSize - nStreamPos;
 
diff --git a/vcl/source/gdi/svmconverter.cxx b/vcl/source/gdi/svmconverter.cxx
index ea21233cc115..2ae6dfd770d8 100644
--- a/vcl/source/gdi/svmconverter.cxx
+++ b/vcl/source/gdi/svmconverter.cxx
@@ -287,7 +287,7 @@ void ImplReadUnicodeComment( sal_uInt32 nStrmPos, SvStream& rIStm, OUString& rSt
     {
         sal_uInt16  nType;
         sal_uInt32  nActionSize;
-        sal_Size    nStringLen;
+        std::size_t nStringLen;
 
         rIStm.Seek( nStrmPos );
         rIStm  .ReadUInt16( nType )
diff --git a/vcl/source/helper/canvasbitmap.cxx b/vcl/source/helper/canvasbitmap.cxx
index 60f4686fdc8a..3c1b95129303 100644
--- a/vcl/source/helper/canvasbitmap.cxx
+++ b/vcl/source/helper/canvasbitmap.cxx
@@ -755,7 +755,7 @@ uno::Sequence<rendering::RGBColor> SAL_CALL VclCanvasBitmap::convertToRGB( const
 {
     SolarMutexGuard aGuard;
 
-    const sal_Size  nLen( deviceColor.getLength() );
+    const std::size_t nLen( deviceColor.getLength() );
     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
     ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
                          "number of channels no multiple of pixel element count",
@@ -771,7 +771,7 @@ uno::Sequence<rendering::RGBColor> SAL_CALL VclCanvasBitmap::convertToRGB( const
         ENSURE_OR_THROW(m_pBmpAcc,
                         "Unable to get BitmapAccess");
 
-        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
+        for( std::size_t i=0; i<nLen; i+=nComponentsPerPixel )
         {
             const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
                 sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));
@@ -787,7 +787,7 @@ uno::Sequence<rendering::RGBColor> SAL_CALL VclCanvasBitmap::convertToRGB( const
         OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
                    "Invalid color channel indices");
 
-        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
+        for( std::size_t i=0; i<nLen; i+=nComponentsPerPixel )
         {
             // TODO(F3): Convert result to sRGB color space
             *pOut++ = rendering::RGBColor(
@@ -804,7 +804,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToARGB( con
 {
     SolarMutexGuard aGuard;
 
-    const sal_Size  nLen( deviceColor.getLength() );
+    const std::size_t nLen( deviceColor.getLength() );
     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
     ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
                          "number of channels no multiple of pixel element count",
@@ -820,7 +820,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToARGB( con
         ENSURE_OR_THROW(m_pBmpAcc,
                         "Unable to get BitmapAccess");
 
-        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
+        for( std::size_t i=0; i<nLen; i+=nComponentsPerPixel )
         {
             const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
                 sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));
@@ -838,7 +838,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToARGB( con
         OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
                    "Invalid color channel indices");
 
-        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
+        for( std::size_t i=0; i<nLen; i+=nComponentsPerPixel )
         {
             // TODO(F3): Convert result to sRGB color space
             const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
@@ -857,7 +857,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToPARGB( co
 {
     SolarMutexGuard aGuard;
 
-    const sal_Size  nLen( deviceColor.getLength() );
+    const std::size_t nLen( deviceColor.getLength() );
     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
     ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
                          "number of channels no multiple of pixel element count",
@@ -873,7 +873,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToPARGB( co
         ENSURE_OR_THROW(m_pBmpAcc,
                         "Unable to get BitmapAccess");
 
-        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
+        for( std::size_t i=0; i<nLen; i+=nComponentsPerPixel )
         {
             const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
                 sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));
@@ -891,7 +891,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToPARGB( co
         OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
                    "Invalid color channel indices");
 
-        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
+        for( std::size_t i=0; i<nLen; i+=nComponentsPerPixel )
         {
             // TODO(F3): Convert result to sRGB color space
             const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
@@ -910,7 +910,7 @@ uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromRGB( const uno::Seq
 {
     SolarMutexGuard aGuard;
 
-    const sal_Size  nLen( rgbColor.getLength() );
+    const std::size_t nLen( rgbColor.getLength() );
     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
 
     uno::Sequence< double > aRes(nLen*nComponentsPerPixel);
@@ -918,7 +918,7 @@ uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromRGB( const uno::Seq
 
     if( m_bPalette )
     {
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             pColors[m_nIndexIndex] = m_pBmpAcc->GetBestPaletteIndex(
                     BitmapColor(toByteColor(rgbColor[i].Red),
@@ -932,7 +932,7 @@ uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromRGB( const uno::Seq
     }
     else
     {
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             pColors[m_nRedIndex]   = rgbColor[i].Red;
             pColors[m_nGreenIndex] = rgbColor[i].Green;
@@ -950,7 +950,7 @@ uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromARGB( const uno::Se
 {
     SolarMutexGuard aGuard;
 
-    const sal_Size  nLen( rgbColor.getLength() );
+    const std::size_t nLen( rgbColor.getLength() );
     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
 
     uno::Sequence< double > aRes(nLen*nComponentsPerPixel);
@@ -958,7 +958,7 @@ uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromARGB( const uno::Se
 
     if( m_bPalette )
     {
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             pColors[m_nIndexIndex] = m_pBmpAcc->GetBestPaletteIndex(
                     BitmapColor(toByteColor(rgbColor[i].Red),
@@ -972,7 +972,7 @@ uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromARGB( const uno::Se
     }
     else
     {
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             pColors[m_nRedIndex]   = rgbColor[i].Red;
             pColors[m_nGreenIndex] = rgbColor[i].Green;
@@ -990,7 +990,7 @@ uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromPARGB( const uno::S
 {
     SolarMutexGuard aGuard;
 
-    const sal_Size  nLen( rgbColor.getLength() );
+    const std::size_t nLen( rgbColor.getLength() );
     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
 
     uno::Sequence< double > aRes(nLen*nComponentsPerPixel);
@@ -998,7 +998,7 @@ uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromPARGB( const uno::S
 
     if( m_bPalette )
     {
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             const double nAlpha( rgbColor[i].Alpha );
             pColors[m_nIndexIndex] = m_pBmpAcc->GetBestPaletteIndex(
@@ -1013,7 +1013,7 @@ uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromPARGB( const uno::S
     }
     else
     {
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             const double nAlpha( rgbColor[i].Alpha );
             pColors[m_nRedIndex]   = rgbColor[i].Red / nAlpha;
@@ -1053,7 +1053,7 @@ uno::Sequence<double> SAL_CALL VclCanvasBitmap::convertFromIntegerColorSpace( co
     {
         SolarMutexGuard aGuard;
 
-        const sal_Size  nLen( deviceColor.getLength() );
+        const std::size_t nLen( deviceColor.getLength() );
         const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
         ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
                              "number of channels no multiple of pixel element count",
@@ -1069,7 +1069,7 @@ uno::Sequence<double> SAL_CALL VclCanvasBitmap::convertFromIntegerColorSpace( co
             ENSURE_OR_THROW(m_pBmpAcc,
                             "Unable to get BitmapAccess");
 
-            for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
+            for( std::size_t i=0; i<nLen; i+=nComponentsPerPixel )
             {
                 const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
                     sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));
@@ -1087,7 +1087,7 @@ uno::Sequence<double> SAL_CALL VclCanvasBitmap::convertFromIntegerColorSpace( co
             OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
                        "Invalid color channel indices");
 
-            for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
+            for( std::size_t i=0; i<nLen; i+=nComponentsPerPixel )
             {
                 // TODO(F3): Convert result to sRGB color space
                 const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
@@ -1133,7 +1133,7 @@ uno::Sequence<rendering::RGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToRGB
     SolarMutexGuard aGuard;
 
     const sal_uInt8*     pIn( reinterpret_cast<const sal_uInt8*>(deviceColor.getConstArray()) );
-    const sal_Size  nLen( deviceColor.getLength() );
+    const std::size_t nLen( deviceColor.getLength() );
     const sal_Int32 nNumColors((nLen*8 + m_nBitsPerOutputPixel-1)/m_nBitsPerOutputPixel);
 
     uno::Sequence< rendering::RGBColor > aRes(nNumColors);
@@ -1145,7 +1145,7 @@ uno::Sequence<rendering::RGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToRGB
     if( m_aBmpEx.IsTransparent() )
     {
         const sal_Int32 nBytesPerPixel((m_nBitsPerOutputPixel+7)/8);
-        for( sal_Size i=0; i<nLen; i+=nBytesPerPixel )
+        for( std::size_t i=0; i<nLen; i+=nBytesPerPixel )
         {
             // if palette, index is guaranteed to be 8 bit
             const BitmapColor aCol =
@@ -1185,7 +1185,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToAR
     SolarMutexGuard aGuard;
 
     const sal_uInt8*     pIn( reinterpret_cast<const sal_uInt8*>(deviceColor.getConstArray()) );
-    const sal_Size  nLen( deviceColor.getLength() );
+    const std::size_t nLen( deviceColor.getLength() );
     const sal_Int32 nNumColors((nLen*8 + m_nBitsPerOutputPixel-1)/m_nBitsPerOutputPixel);
 
     uno::Sequence< rendering::ARGBColor > aRes(nNumColors);
@@ -1199,7 +1199,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToAR
         const long      nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
         const sal_Int32 nBytesPerPixel((m_nBitsPerOutputPixel+7)/8);
         const sal_uInt8 nAlphaFactor( m_aBmpEx.IsAlpha() ? 1 : 255 );
-        for( sal_Size i=0; i<nLen; i+=nBytesPerPixel )
+        for( std::size_t i=0; i<nLen; i+=nBytesPerPixel )
         {
             // if palette, index is guaranteed to be 8 bit
             const BitmapColor aCol =
@@ -1240,7 +1240,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToPA
     SolarMutexGuard aGuard;
 
     const sal_uInt8*     pIn( reinterpret_cast<const sal_uInt8*>(deviceColor.getConstArray()) );
-    const sal_Size  nLen( deviceColor.getLength() );
+    const std::size_t nLen( deviceColor.getLength() );
     const sal_Int32 nNumColors((nLen*8 + m_nBitsPerOutputPixel-1)/m_nBitsPerOutputPixel);
 
     uno::Sequence< rendering::ARGBColor > aRes(nNumColors);
@@ -1254,7 +1254,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToPA
         const long      nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
         const sal_Int32 nBytesPerPixel((m_nBitsPerOutputPixel+7)/8);
         const sal_uInt8 nAlphaFactor( m_aBmpEx.IsAlpha() ? 1 : 255 );
-        for( sal_Size i=0; i<nLen; i+=nBytesPerPixel )
+        for( std::size_t i=0; i<nLen; i+=nBytesPerPixel )
         {
             // if palette, index is guaranteed to be 8 bit
             const BitmapColor aCol =
@@ -1295,7 +1295,7 @@ uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromRGB( con
 {
     SolarMutexGuard aGuard;
 
-    const sal_Size  nLen( rgbColor.getLength() );
+    const std::size_t nLen( rgbColor.getLength() );
     const sal_Int32 nNumBytes((nLen*m_nBitsPerOutputPixel+7)/8);
 
     uno::Sequence< sal_Int8 > aRes(nNumBytes);
@@ -1304,7 +1304,7 @@ uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromRGB( con
     if( m_aBmpEx.IsTransparent() )
     {
         const long nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             const BitmapColor aCol(toByteColor(rgbColor[i].Red),
                                    toByteColor(rgbColor[i].Green),
@@ -1322,7 +1322,7 @@ uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromRGB( con
     }
     else
     {
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             const BitmapColor aCol(toByteColor(rgbColor[i].Red),
                                    toByteColor(rgbColor[i].Green),
@@ -1344,7 +1344,7 @@ uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromARGB( co
 {
     SolarMutexGuard aGuard;
 
-    const sal_Size  nLen( rgbColor.getLength() );
+    const std::size_t nLen( rgbColor.getLength() );
     const sal_Int32 nNumBytes((nLen*m_nBitsPerOutputPixel+7)/8);
 
     uno::Sequence< sal_Int8 > aRes(nNumBytes);
@@ -1353,7 +1353,7 @@ uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromARGB( co
     if( m_aBmpEx.IsTransparent() )
     {
         const long nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             const BitmapColor aCol(toByteColor(rgbColor[i].Red),
                                    toByteColor(rgbColor[i].Green),
@@ -1371,7 +1371,7 @@ uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromARGB( co
     }
     else
     {
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             const BitmapColor aCol(toByteColor(rgbColor[i].Red),
                                    toByteColor(rgbColor[i].Green),
@@ -1393,7 +1393,7 @@ uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromPARGB( c
 {
     SolarMutexGuard aGuard;
 
-    const sal_Size  nLen( rgbColor.getLength() );
+    const std::size_t nLen( rgbColor.getLength() );
     const sal_Int32 nNumBytes((nLen*m_nBitsPerOutputPixel+7)/8);
 
     uno::Sequence< sal_Int8 > aRes(nNumBytes);
@@ -1402,7 +1402,7 @@ uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromPARGB( c
     if( m_aBmpEx.IsTransparent() )
     {
         const long nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             const double nAlpha( rgbColor[i].Alpha );
             const BitmapColor aCol(toByteColor(rgbColor[i].Red / nAlpha),
@@ -1421,7 +1421,7 @@ uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromPARGB( c
     }
     else
     {
-        for( sal_Size i=0; i<nLen; ++i )
+        for( std::size_t i=0; i<nLen; ++i )
         {
             const BitmapColor aCol(toByteColor(rgbColor[i].Red),
                                    toByteColor(rgbColor[i].Green),
diff --git a/vcl/source/helper/canvastools.cxx b/vcl/source/helper/canvastools.cxx
index de6fcaa44b7d..a25b983b78b3 100644
--- a/vcl/source/helper/canvastools.cxx
+++ b/vcl/source/helper/canvastools.cxx
@@ -220,7 +220,7 @@ namespace vcl
                     const uno::Sequence<sal_Int8> aTags(
                         aLayout.ColorSpace->getComponentTags() );
                     const sal_Int8* pStart(aTags.getConstArray());
-                    const sal_Size  nLen(aTags.getLength());
+                    const std::size_t  nLen(aTags.getLength());
                     const sal_Int8* pEnd(pStart+nLen);
 
                     const std::ptrdiff_t nAlphaIndex =
@@ -450,14 +450,14 @@ namespace vcl
                 virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const double*  pIn( deviceColor.getConstArray() );
-                    const sal_Size nLen( deviceColor.getLength() );
+                    const std::size_t nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::RGBColor > aRes(nLen/4);
                     rendering::RGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::RGBColor(pIn[0],pIn[1],pIn[2]);
                         pIn += 4;
@@ -467,14 +467,14 @@ namespace vcl
                 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const double*  pIn( deviceColor.getConstArray() );
-                    const sal_Size nLen( deviceColor.getLength() );
+                    const std::size_t nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                     rendering::ARGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::ARGBColor(pIn[3],pIn[0],pIn[1],pIn[2]);
                         pIn += 4;
@@ -484,14 +484,14 @@ namespace vcl
                 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const double*  pIn( deviceColor.getConstArray() );
-                    const sal_Size nLen( deviceColor.getLength() );
+                    const std::size_t nLen( deviceColor.getLength() );
                     ENSURE_ARG_OR_THROW2(nLen%4==0,
                                          "number of channels no multiple of 4",
                                          static_cast<rendering::XColorSpace*>(this), 0);
 
                     uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
                     rendering::ARGBColor* pOut( aRes.getArray() );
-                    for( sal_Size i=0; i<nLen; i+=4 )
+                    for( std::size_t i=0; i<nLen; i+=4 )
                     {
                         *pOut++ = rendering::ARGBColor(pIn[3],pIn[3]*pIn[0],pIn[3]*pIn[1],pIn[3]*pIn[2]);
                         pIn += 4;
@@ -501,11 +501,11 @@ namespace vcl
                 virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::RGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size             nLen( rgbColor.getLength() );
+                    const std::size_t             nLen( rgbColor.getLength() );
 
                     uno::Sequence< double > aRes(nLen*4);
                     double* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = pIn->Red;
                         *pColors++ = pIn->Green;
@@ -518,11 +518,11 @@ namespace vcl
                 virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size              nLen( rgbColor.getLength() );
+                    const std::size_t              nLen( rgbColor.getLength() );
 
                     uno::Sequence< double > aRes(nLen*4);
                     double* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = pIn->Red;
                         *pColors++ = pIn->Green;
@@ -535,11 +535,11 @@ namespace vcl
                 virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) override
                 {
                     const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
-                    const sal_Size              nLen( rgbColor.getLength() );
+                    const std::size_t              nLen( rgbColor.getLength() );
 
                     uno::Sequence< double > aRes(nLen*4);
                     double* pColors=aRes.getArray();
-                    for( sal_Size i=0; i<nLen; ++i )
+                    for( std::size_t i=0; i<nLen; ++i )
                     {
                         *pColors++ = pIn->Red/pIn->Alpha;
                         *pColors++ = pIn->Green/pIn->Alpha;
diff --git a/vcl/unx/generic/app/i18n_ic.cxx b/vcl/unx/generic/app/i18n_ic.cxx
index e83a3f531810..abac4c89af76 100644
--- a/vcl/unx/generic/app/i18n_ic.cxx
+++ b/vcl/unx/generic/app/i18n_ic.cxx
@@ -512,7 +512,7 @@ SalI18N_InputContext::SupportInputMethodStyle( XIMStyles *pIMStyles )
 // handle extended and normal key input
 
 void
-SalI18N_InputContext::CommitKeyEvent(sal_Unicode* pText, sal_Size nLength)
+SalI18N_InputContext::CommitKeyEvent(sal_Unicode* pText, std::size_t nLength)
 {
     if (nLength == 1 && IsControlCode(pText[0]))
         return;
diff --git a/vcl/unx/generic/dtrans/X11_selection.cxx b/vcl/unx/generic/dtrans/X11_selection.cxx
index 89caeb7da885..cca391c159d7 100644
--- a/vcl/unx/generic/dtrans/X11_selection.cxx
+++ b/vcl/unx/generic/dtrans/X11_selection.cxx
@@ -1412,7 +1412,7 @@ PixmapHolder* SelectionManager::getPixmapHolder( Atom selection )
     return it->second->m_pPixmap;
 }
 
-static sal_Size GetTrueFormatSize(int nFormat)
+static std::size_t GetTrueFormatSize(int nFormat)
 {
     // http://mail.gnome.org/archives/wm-spec-list/2003-March/msg00067.html
     return nFormat == 32 ? sizeof(long) : nFormat/8;
@@ -1541,7 +1541,7 @@ bool SelectionManager::sendData( SelectionAdaptor* pAdaptor,
         }
         else
         {
-            sal_Size nUnitSize = GetTrueFormatSize(nFormat);
+            std::size_t nUnitSize = GetTrueFormatSize(nFormat);
             XChangeProperty( m_pDisplay,
                              requestor,
                              property,
@@ -1846,7 +1846,7 @@ bool SelectionManager::handleReceivePropertyNotify( XPropertyEvent& rNotify )
                      nFormat, nBytes );
 #endif
 
-            sal_Size nUnitSize = GetTrueFormatSize(nFormat);
+            std::size_t nUnitSize = GetTrueFormatSize(nFormat);
 
             if( it->second->m_eState == Selection::WaitingForData ||
                 it->second->m_eState == Selection::WaitingForResponse )
@@ -1948,7 +1948,7 @@ bool SelectionManager::handleSendPropertyNotify( XPropertyEvent& rNotify )
                          (const unsigned char*)rInc.m_aData.getConstArray()+rInc.m_nBufferPos );
 #endif
 
-                sal_Size nUnitSize = GetTrueFormatSize(rInc.m_nFormat);
+                std::size_t nUnitSize = GetTrueFormatSize(rInc.m_nFormat);
 
                 XChangeProperty( m_pDisplay,
                                  rInc.m_aRequestor,
@@ -2046,7 +2046,7 @@ bool SelectionManager::handleSelectionNotify( XSelectionEvent& rNotify )
                                     &pData );
             }
             it->second->m_eState        = Selection::Inactive;
-            sal_Size nUnitSize = GetTrueFormatSize(nFormat);
+            std::size_t nUnitSize = GetTrueFormatSize(nFormat);
             it->second->m_aData         = Sequence< sal_Int8 >(reinterpret_cast<sal_Int8*>(pData), nItems * nUnitSize);
             it->second->m_aDataArrived.set();
             if( pData )
diff --git a/vcl/unx/generic/print/psputil.cxx b/vcl/unx/generic/print/psputil.cxx
index 7c363b9898ee..53b94c465e99 100644
--- a/vcl/unx/generic/print/psputil.cxx
+++ b/vcl/unx/generic/print/psputil.cxx
@@ -210,9 +210,9 @@ ConverterFactory::Get (rtl_TextEncoding nEncoding)
 
 // wrapper for rtl_convertUnicodeToText that handles the usual cases for
 // textconversion in drawtext
-sal_Size
+std::size_t
 ConverterFactory::Convert (const sal_Unicode *pText, int nTextLen,
-                           unsigned char *pBuffer, sal_Size nBufferSize, rtl_TextEncoding nEncoding)
+                           unsigned char *pBuffer, std::size_t nBufferSize, rtl_TextEncoding nEncoding)
 {
     const sal_uInt32 nCvtFlags =  RTL_UNICODETOTEXT_FLAGS_UNDEFINED_QUESTIONMARK
         | RTL_UNICODETOTEXT_FLAGS_INVALID_QUESTIONMARK ;
diff --git a/vcl/unx/generic/print/psputil.hxx b/vcl/unx/generic/print/psputil.hxx
index 01a2d4f3cb31..b035de16aafe 100644
--- a/vcl/unx/generic/print/psputil.hxx
+++ b/vcl/unx/generic/print/psputil.hxx
@@ -53,8 +53,8 @@ public:
     ConverterFactory();
     ~ConverterFactory();
     rtl_UnicodeToTextConverter  Get (rtl_TextEncoding nEncoding);
-    sal_Size                    Convert (const sal_Unicode *pText, int nTextLen,
-                                         unsigned char *pBuffer, sal_Size nBufferSize,
+    std::size_t                 Convert (const sal_Unicode *pText, int nTextLen,
+                                         unsigned char *pBuffer, std::size_t nBufferSize,
                                          rtl_TextEncoding nEncoding);
 private:
 
diff --git a/vcl/unx/generic/print/text_gfx.cxx b/vcl/unx/generic/print/text_gfx.cxx
index 723fd46e2fa7..bcb46583a8ae 100644
--- a/vcl/unx/generic/print/text_gfx.cxx
+++ b/vcl/unx/generic/print/text_gfx.cxx
@@ -536,7 +536,7 @@ PrinterGfx::LicenseWarning(const Point& rPoint, const sal_Unicode* pStr,
             RTL_TEXTENCODING_ASCII_US);
     PSSetFont (aFontName, RTL_TEXTENCODING_ISO_8859_1);
 
-    sal_Size  nSize    = 4 * nLen;
+    std::size_t  nSize    = 4 * nLen;
     unsigned char* pBuffer = static_cast<unsigned char*>(alloca (nSize* sizeof(unsigned char)));
 
     ConverterFactory &rCvt = GetConverterFactory ();
diff --git a/vcl/win/gdi/salprn.cxx b/vcl/win/gdi/salprn.cxx
index 04478467380c..926854aeeb2d 100644
--- a/vcl/win/gdi/salprn.cxx
+++ b/vcl/win/gdi/salprn.cxx
@@ -382,7 +382,7 @@ static bool ImplUpdateSalJobSetup( WinSalInfoPrinter* pPrinter, ImplJobSetup* pS
     }
 
     // make Outputbuffer
-    const sal_Size nDriverDataLen = sizeof(SalDriverData) + nSysJobSize-1;
+    const std::size_t nDriverDataLen = sizeof(SalDriverData) + nSysJobSize-1;
     pOutBuffer                  = (SalDriverData*)rtl_allocateZeroMemory( nDriverDataLen );
     pOutBuffer->mnSysSignature  = SAL_DRIVERDATA_SYSSIGN;
     // calculate driver data offset including structure padding