[Libreoffice-commits] core.git: vcl/unx
Libreoffice Gerrit user
logerrit at kemper.freedesktop.org
Fri Jan 18 10:15:13 UTC 2019
vcl/unx/generic/print/bitmap_gfx.cxx | 93 ++++++++----------
vcl/unx/generic/print/common_gfx.cxx | 178 ++++++++++++++++-------------------
vcl/unx/generic/print/printerjob.cxx | 92 ++++++++----------
vcl/unx/generic/print/psputil.cxx | 46 +++++----
vcl/unx/generic/print/psputil.hxx | 17 ++-
5 files changed, 211 insertions(+), 215 deletions(-)
New commits:
commit 49d8cc18a85b7cc30b04b56d52b89d9016d16120
Author: Stephan Bergmann <sbergman at redhat.com>
AuthorDate: Fri Jan 18 08:18:56 2019 +0100
Commit: Stephan Bergmann <sbergman at redhat.com>
CommitDate: Fri Jan 18 11:14:42 2019 +0100
In vcl/unx/generic/print/, use OStringBuffer instead of fixed-size arrays
...to avoid potential overflow in psp::appendStr as reported by GCC with
--enable-optimized:
> vcl/unx/generic/print/psputil.cxx: In function ‘sal_Int32 psp::appendStr(const sal_Char*, sal_Char*)’:
> vcl/unx/generic/print/psputil.cxx:127:13: error: ‘char* strncpy(char*, const char*, size_t)’ specified bound depends on the length of the source argument [-Werror=stringop-overflow=]
> strncpy (pDst, pSrc, nBytes + 1);
> ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
> vcl/unx/generic/print/psputil.cxx:126:31: note: length computed here
> sal_Int32 nBytes = strlen (pSrc);
> ~~~~~~~^~~~~~
Most of the time the original code wrote at the "end" of its char array, so
replacements with functionality based on OStringBuffer::append was
straightforward. A few places needed to use OStringBuffer::insert to mimic the
original code's writing at somewhat random positions in the char array.
The functions now taking an OStringBuffer argument still return the amount of
characters written. Even if that information would (indirectly) also be
available as part of the OStringBuffer's state, keeping the (somewhat redundant
now) counting of positions in the calling code should help avoid regressions.
Some of the code may be simplified in follow-up commits, dropping the external
counting.
The original psp::getValueOfDouble is still used elsewhere, so leave it alone
for now and add an OStringBuffer overload.
Change-Id: I2bb5d51505ca70cba485e6843183496ea3a4ce18
Reviewed-on: https://gerrit.libreoffice.org/66564
Tested-by: Jenkins
Reviewed-by: Stephan Bergmann <sbergman at redhat.com>
diff --git a/vcl/unx/generic/print/bitmap_gfx.cxx b/vcl/unx/generic/print/bitmap_gfx.cxx
index eca8cbb90921..b52b892b3462 100644
--- a/vcl/unx/generic/print/bitmap_gfx.cxx
+++ b/vcl/unx/generic/print/bitmap_gfx.cxx
@@ -64,7 +64,7 @@ private:
osl::File* const mpFile;
sal_uInt32 mnColumn;
sal_uInt32 mnOffset;
- sal_Char mpFileBuffer[nBufferSize + 16];
+ OStringBuffer mpFileBuffer;
public:
@@ -91,13 +91,13 @@ HexEncoder::~HexEncoder ()
void
HexEncoder::WriteAscii (sal_uInt8 nByte)
{
- sal_uInt32 nOff = psp::getHexValueOf (nByte, mpFileBuffer + mnOffset);
+ sal_uInt32 nOff = psp::getHexValueOf (nByte, mpFileBuffer);
mnColumn += nOff;
mnOffset += nOff;
if (mnColumn >= nLineLength)
{
- mnOffset += psp::appendStr ("\n", mpFileBuffer + mnOffset);
+ mnOffset += psp::appendStr ("\n", mpFileBuffer);
mnColumn = 0;
}
if (mnOffset >= nBufferSize)
@@ -115,7 +115,7 @@ HexEncoder::FlushLine ()
{
if (mnOffset > 0)
{
- WritePS (mpFile, mpFileBuffer, mnOffset);
+ WritePS (mpFile, mpFileBuffer.makeStringAndClear());
mnOffset = 0;
}
}
@@ -133,7 +133,7 @@ private:
sal_uInt32 mnColumn;
sal_uInt32 mnOffset;
- sal_Char mpFileBuffer[nBufferSize + 16];
+ OStringBuffer mpFileBuffer;
inline void PutByte (sal_uInt8 nByte);
inline void PutEOD ();
@@ -182,7 +182,7 @@ Ascii85Encoder::ConvertToAscii85 ()
if (nByteValue == 0 && mnByte == 4)
{
/* special case of 4 Bytes in row */
- mpFileBuffer [mnOffset] = 'z';
+ mpFileBuffer.append('z');
mnOffset += 1;
mnColumn += 1;
@@ -194,21 +194,22 @@ Ascii85Encoder::ConvertToAscii85 ()
// Of the up to 5 characters to be generated, do not generate the last (4 - mnByte) ones
// that correspond to the (4 - mnByte) zero padding bytes added to the input:
+ auto const pos = mpFileBuffer.getLength();
if (mnByte == 4) {
- mpFileBuffer [mnOffset + 4] = (nByteValue % 85) + 33;
+ mpFileBuffer.insert(pos, char((nByteValue % 85) + 33));
}
nByteValue /= 85;
if (mnByte >= 3) {
- mpFileBuffer [mnOffset + 3] = (nByteValue % 85) + 33;
+ mpFileBuffer.insert(pos, char((nByteValue % 85) + 33));
}
nByteValue /= 85;
if (mnByte >= 2) {
- mpFileBuffer [mnOffset + 2] = (nByteValue % 85) + 33;
+ mpFileBuffer.insert(pos, char((nByteValue % 85) + 33));
}
nByteValue /= 85;
- mpFileBuffer [mnOffset + 1] = (nByteValue % 85) + 33;
+ mpFileBuffer.insert(pos, char((nByteValue % 85) + 33));
nByteValue /= 85;
- mpFileBuffer [mnOffset + 0] = (nByteValue % 85) + 33;
+ mpFileBuffer.insert(pos, char((nByteValue % 85) + 33));
mnColumn += (mnByte + 1);
mnOffset += (mnByte + 1);
@@ -217,10 +218,9 @@ Ascii85Encoder::ConvertToAscii85 ()
if (mnColumn > nLineLength)
{
sal_uInt32 nEolOff = mnColumn - nLineLength;
- sal_uInt32 nBufOff = mnOffset - nEolOff;
+ auto const posNl = pos + (mnByte + 1) - nEolOff;
- std::memmove (mpFileBuffer + nBufOff + 1, mpFileBuffer + nBufOff, nEolOff);
- mpFileBuffer[ nBufOff ] = '\n';
+ mpFileBuffer.insert(posNl, '\n');
mnOffset++;
mnColumn = nEolOff;
@@ -239,7 +239,7 @@ Ascii85Encoder::WriteAscii (sal_uInt8 nByte)
if (mnColumn >= nLineLength)
{
- mnOffset += psp::appendStr ("\n", mpFileBuffer + mnOffset);
+ mnOffset += psp::appendStr ("\n", mpFileBuffer);
mnColumn = 0;
}
if (mnOffset >= nBufferSize)
@@ -257,7 +257,7 @@ Ascii85Encoder::FlushLine ()
{
if (mnOffset > 0)
{
- WritePS (mpFile, mpFileBuffer, mnOffset);
+ WritePS (mpFile, mpFileBuffer.makeStringAndClear());
mnOffset = 0;
}
}
@@ -476,23 +476,22 @@ PrinterGfx::DrawPS1GrayImage (const PrinterBmp& rBitmap, const tools::Rectangle&
sal_uInt32 nWidth = rArea.GetWidth();
sal_uInt32 nHeight = rArea.GetHeight();
- sal_Char pGrayImage [512];
- sal_Int32 nChar = 0;
+ OStringBuffer pGrayImage;
// image header
- nChar += psp::getValueOf (nWidth, pGrayImage + nChar);
- nChar += psp::appendStr (" ", pGrayImage + nChar);
- nChar += psp::getValueOf (nHeight, pGrayImage + nChar);
- nChar += psp::appendStr (" 8 ", pGrayImage + nChar);
- nChar += psp::appendStr ("[ 1 0 0 1 0 ", pGrayImage + nChar);
- nChar += psp::getValueOf (nHeight, pGrayImage + nChar);
- nChar += psp::appendStr ("]", pGrayImage + nChar);
- nChar += psp::appendStr (" {currentfile ", pGrayImage + nChar);
- nChar += psp::getValueOf (nWidth, pGrayImage + nChar);
- nChar += psp::appendStr (" string readhexstring pop}\n", pGrayImage + nChar);
- nChar += psp::appendStr ("image\n", pGrayImage + nChar);
-
- WritePS (mpPageBody, pGrayImage, nChar);
+ psp::getValueOf (nWidth, pGrayImage);
+ psp::appendStr (" ", pGrayImage);
+ psp::getValueOf (nHeight, pGrayImage);
+ psp::appendStr (" 8 ", pGrayImage);
+ psp::appendStr ("[ 1 0 0 1 0 ", pGrayImage);
+ psp::getValueOf (nHeight, pGrayImage);
+ psp::appendStr ("]", pGrayImage);
+ psp::appendStr (" {currentfile ", pGrayImage);
+ psp::getValueOf (nWidth, pGrayImage);
+ psp::appendStr (" string readhexstring pop}\n", pGrayImage);
+ psp::appendStr ("image\n", pGrayImage);
+
+ WritePS (mpPageBody, pGrayImage.makeStringAndClear());
// image body
std::unique_ptr<HexEncoder> xEncoder(new HexEncoder (mpPageBody));
@@ -520,8 +519,7 @@ PrinterGfx::DrawPS1GrayImage (const PrinterBmp& rBitmap, const tools::Rectangle&
void
PrinterGfx::writePS2ImageHeader (const tools::Rectangle& rArea, psp::ImageType nType)
{
- sal_Int32 nChar = 0;
- sal_Char pImage [512];
+ OStringBuffer pImage;
sal_Int32 nDictType = 0;
switch (nType)
@@ -533,16 +531,16 @@ PrinterGfx::writePS2ImageHeader (const tools::Rectangle& rArea, psp::ImageType n
default: break;
}
- nChar += psp::getValueOf (rArea.GetWidth(), pImage + nChar);
- nChar += psp::appendStr (" ", pImage + nChar);
- nChar += psp::getValueOf (rArea.GetHeight(), pImage + nChar);
- nChar += psp::appendStr (" ", pImage + nChar);
- nChar += psp::getValueOf (nDictType, pImage + nChar);
- nChar += psp::appendStr (" ", pImage + nChar);
- nChar += psp::getValueOf (sal_Int32(1), pImage + nChar); // nCompressType
- nChar += psp::appendStr (" psp_imagedict image\n", pImage + nChar);
+ psp::getValueOf (rArea.GetWidth(), pImage);
+ psp::appendStr (" ", pImage);
+ psp::getValueOf (rArea.GetHeight(), pImage);
+ psp::appendStr (" ", pImage);
+ psp::getValueOf (nDictType, pImage);
+ psp::appendStr (" ", pImage);
+ psp::getValueOf (sal_Int32(1), pImage); // nCompressType
+ psp::appendStr (" psp_imagedict image\n", pImage);
- WritePS (mpPageBody, pImage, nChar);
+ WritePS (mpPageBody, pImage.makeStringAndClear());
}
void
@@ -564,15 +562,14 @@ PrinterGfx::writePS2Colorspace(const PrinterBmp& rBitmap, psp::ImageType nType)
case psp::ImageType::PaletteImage:
{
- sal_Int32 nChar = 0;
- sal_Char pImage [4096];
+ OStringBuffer pImage;
const sal_uInt32 nSize = rBitmap.GetPaletteEntryCount();
- nChar += psp::appendStr ("[/Indexed /DeviceRGB ", pImage + nChar);
- nChar += psp::getValueOf (nSize - 1, pImage + nChar);
- nChar += psp::appendStr ("\npsp_lzwstring\n", pImage + nChar);
- WritePS (mpPageBody, pImage, nChar);
+ psp::appendStr ("[/Indexed /DeviceRGB ", pImage);
+ psp::getValueOf (nSize - 1, pImage);
+ psp::appendStr ("\npsp_lzwstring\n", pImage);
+ WritePS (mpPageBody, pImage.makeStringAndClear());
std::unique_ptr<ByteEncoder> xEncoder(new LZWEncoder(mpPageBody));
for (sal_uInt32 i = 0; i < nSize; i++)
diff --git a/vcl/unx/generic/print/common_gfx.cxx b/vcl/unx/generic/print/common_gfx.cxx
index a4fc227ad74f..a92d366ccd1d 100644
--- a/vcl/unx/generic/print/common_gfx.cxx
+++ b/vcl/unx/generic/print/common_gfx.cxx
@@ -300,23 +300,23 @@ PrinterGfx::EndSetClipRegion()
void
PrinterGfx::DrawRect (const tools::Rectangle& rRectangle )
{
- char pRect [128];
- sal_Int32 nChar = 0;
-
- nChar = psp::getValueOf (rRectangle.TopLeft().X(), pRect);
- nChar += psp::appendStr (" ", pRect + nChar);
- nChar += psp::getValueOf (rRectangle.TopLeft().Y(), pRect + nChar);
- nChar += psp::appendStr (" ", pRect + nChar);
- nChar += psp::getValueOf (rRectangle.GetWidth(), pRect + nChar);
- nChar += psp::appendStr (" ", pRect + nChar);
- nChar += psp::getValueOf (rRectangle.GetHeight(), pRect + nChar);
- nChar += psp::appendStr (" ", pRect + nChar);
+ OStringBuffer pRect;
+
+ psp::getValueOf (rRectangle.TopLeft().X(), pRect);
+ psp::appendStr (" ", pRect);
+ psp::getValueOf (rRectangle.TopLeft().Y(), pRect);
+ psp::appendStr (" ", pRect);
+ psp::getValueOf (rRectangle.GetWidth(), pRect);
+ psp::appendStr (" ", pRect);
+ psp::getValueOf (rRectangle.GetHeight(), pRect);
+ psp::appendStr (" ", pRect);
+ auto const rect = pRect.makeStringAndClear();
if( maFillColor.Is() )
{
PSSetColor (maFillColor);
PSSetColor ();
- WritePS (mpPageBody, pRect, nChar);
+ WritePS (mpPageBody, rect);
WritePS (mpPageBody, "rectfill\n");
}
if( maLineColor.Is() )
@@ -324,7 +324,7 @@ PrinterGfx::DrawRect (const tools::Rectangle& rRectangle )
PSSetColor (maLineColor);
PSSetColor ();
PSSetLineWidth ();
- WritePS (mpPageBody, pRect, nChar);
+ WritePS (mpPageBody, rect);
WritePS (mpPageBody, "rectstroke\n");
}
}
@@ -672,13 +672,12 @@ PrinterGfx::PSSetLineWidth ()
{
if( currentState().mfLineWidth != maVirtualStatus.mfLineWidth )
{
- char pBuffer[128];
- sal_Int32 nChar = 0;
+ OStringBuffer pBuffer;
currentState().mfLineWidth = maVirtualStatus.mfLineWidth;
- nChar = psp::getValueOfDouble (pBuffer, maVirtualStatus.mfLineWidth, 5);
- nChar += psp::appendStr (" setlinewidth\n", pBuffer + nChar);
- WritePS (mpPageBody, pBuffer, nChar);
+ psp::getValueOfDouble (pBuffer, maVirtualStatus.mfLineWidth, 5);
+ psp::appendStr (" setlinewidth\n", pBuffer);
+ WritePS (mpPageBody, pBuffer.makeStringAndClear());
}
}
@@ -691,30 +690,29 @@ PrinterGfx::PSSetColor ()
{
currentState().maColor = rColor;
- char pBuffer[128];
- sal_Int32 nChar = 0;
+ OStringBuffer pBuffer;
if( mbColor )
{
- nChar = psp::getValueOfDouble (pBuffer,
+ psp::getValueOfDouble (pBuffer,
static_cast<double>(rColor.GetRed()) / 255.0, 5);
- nChar += psp::appendStr (" ", pBuffer + nChar);
- nChar += psp::getValueOfDouble (pBuffer + nChar,
+ psp::appendStr (" ", pBuffer);
+ psp::getValueOfDouble (pBuffer,
static_cast<double>(rColor.GetGreen()) / 255.0, 5);
- nChar += psp::appendStr (" ", pBuffer + nChar);
- nChar += psp::getValueOfDouble (pBuffer + nChar,
+ psp::appendStr (" ", pBuffer);
+ psp::getValueOfDouble (pBuffer,
static_cast<double>(rColor.GetBlue()) / 255.0, 5);
- nChar += psp::appendStr (" setrgbcolor\n", pBuffer + nChar );
+ psp::appendStr (" setrgbcolor\n", pBuffer );
}
else
{
Color aColor( rColor.GetRed(), rColor.GetGreen(), rColor.GetBlue() );
sal_uInt8 nCol = aColor.GetLuminance();
- nChar = psp::getValueOfDouble( pBuffer, static_cast<double>(nCol) / 255.0, 5 );
- nChar += psp::appendStr( " setgray\n", pBuffer + nChar );
+ psp::getValueOfDouble( pBuffer, static_cast<double>(nCol) / 255.0, 5 );
+ psp::appendStr( " setgray\n", pBuffer );
}
- WritePS (mpPageBody, pBuffer, nChar);
+ WritePS (mpPageBody, pBuffer.makeStringAndClear());
}
}
@@ -742,8 +740,7 @@ PrinterGfx::PSSetFont ()
sal_Int32 nTextWidth = rCurrent.mnTextWidth ? rCurrent.mnTextWidth
: rCurrent.mnTextHeight;
- sal_Char pSetFont [256];
- sal_Int32 nChar = 0;
+ OStringBuffer pSetFont;
// postscript based fonts need reencoding
if ( ( rCurrent.maEncoding == RTL_TEXTENCODING_MS_1252)
@@ -756,43 +753,43 @@ PrinterGfx::PSSetFont ()
psp::GlyphSet::GetReencodedFontName (rCurrent.maEncoding,
rCurrent.maFont);
- nChar += psp::appendStr ("(", pSetFont + nChar);
- nChar += psp::appendStr (aReencodedFont.getStr(),
- pSetFont + nChar);
- nChar += psp::appendStr (") cvn findfont ",
- pSetFont + nChar);
+ psp::appendStr ("(", pSetFont);
+ psp::appendStr (aReencodedFont.getStr(),
+ pSetFont);
+ psp::appendStr (") cvn findfont ",
+ pSetFont);
}
else
// tt based fonts mustn't reencode, the encoding is implied by the fontname
// same for symbol type1 fonts, don't try to touch them
{
- nChar += psp::appendStr ("(", pSetFont + nChar);
- nChar += psp::appendStr (rCurrent.maFont.getStr(),
- pSetFont + nChar);
- nChar += psp::appendStr (") cvn findfont ",
- pSetFont + nChar);
+ psp::appendStr ("(", pSetFont);
+ psp::appendStr (rCurrent.maFont.getStr(),
+ pSetFont);
+ psp::appendStr (") cvn findfont ",
+ pSetFont);
}
if( ! rCurrent.mbArtItalic )
{
- nChar += psp::getValueOf (nTextWidth, pSetFont + nChar);
- nChar += psp::appendStr (" ", pSetFont + nChar);
- nChar += psp::getValueOf (-nTextHeight, pSetFont + nChar);
- nChar += psp::appendStr (" matrix scale makefont setfont\n", pSetFont + nChar);
+ psp::getValueOf (nTextWidth, pSetFont);
+ psp::appendStr (" ", pSetFont);
+ psp::getValueOf (-nTextHeight, pSetFont);
+ psp::appendStr (" matrix scale makefont setfont\n", pSetFont);
}
else // skew 15 degrees to right
{
- nChar += psp::appendStr ( " [", pSetFont + nChar);
- nChar += psp::getValueOf (nTextWidth, pSetFont + nChar);
- nChar += psp::appendStr (" 0 ", pSetFont + nChar);
- nChar += psp::getValueOfDouble (pSetFont + nChar, 0.27*static_cast<double>(nTextWidth), 3 );
- nChar += psp::appendStr ( " ", pSetFont + nChar);
- nChar += psp::getValueOf (-nTextHeight, pSetFont + nChar);
-
- nChar += psp::appendStr (" 0 0] makefont setfont\n", pSetFont + nChar);
+ psp::appendStr ( " [", pSetFont);
+ psp::getValueOf (nTextWidth, pSetFont);
+ psp::appendStr (" 0 ", pSetFont);
+ psp::getValueOfDouble (pSetFont, 0.27*static_cast<double>(nTextWidth), 3 );
+ psp::appendStr ( " ", pSetFont);
+ psp::getValueOf (-nTextHeight, pSetFont);
+
+ psp::appendStr (" 0 0] makefont setfont\n", pSetFont);
}
- WritePS (mpPageBody, pSetFont, nChar);
+ WritePS (mpPageBody, pSetFont.makeStringAndClear());
}
@@ -809,33 +806,29 @@ PrinterGfx::PSRotate (sal_Int32 nAngle)
sal_Int32 nFullAngle = nPostScriptAngle / 10;
sal_Int32 nTenthAngle = nPostScriptAngle % 10;
- sal_Char pRotate [48];
- sal_Int32 nChar = 0;
+ OStringBuffer pRotate;
- nChar = psp::getValueOf (nFullAngle, pRotate);
- nChar += psp::appendStr (".", pRotate + nChar);
- nChar += psp::getValueOf (nTenthAngle, pRotate + nChar);
- nChar += psp::appendStr (" rotate\n", pRotate + nChar);
+ psp::getValueOf (nFullAngle, pRotate);
+ psp::appendStr (".", pRotate);
+ psp::getValueOf (nTenthAngle, pRotate);
+ psp::appendStr (" rotate\n", pRotate);
- WritePS (mpPageBody, pRotate, nChar);
+ WritePS (mpPageBody, pRotate.makeStringAndClear());
}
void
PrinterGfx::PSPointOp (const Point& rPoint, const sal_Char* pOperator)
{
- sal_Char pPSCommand [48];
- sal_Int32 nChar = 0;
-
- nChar = psp::getValueOf (rPoint.X(), pPSCommand);
- nChar += psp::appendStr (" ", pPSCommand + nChar);
- nChar += psp::getValueOf (rPoint.Y(), pPSCommand + nChar);
- nChar += psp::appendStr (" ", pPSCommand + nChar);
- nChar += psp::appendStr (pOperator, pPSCommand + nChar);
- nChar += psp::appendStr ("\n", pPSCommand + nChar);
+ OStringBuffer pPSCommand;
- DBG_ASSERT (nChar < 48, "Buffer overflow in PSPointOp");
+ psp::getValueOf (rPoint.X(), pPSCommand);
+ psp::appendStr (" ", pPSCommand);
+ psp::getValueOf (rPoint.Y(), pPSCommand);
+ psp::appendStr (" ", pPSCommand);
+ psp::appendStr (pOperator, pPSCommand);
+ psp::appendStr ("\n", pPSCommand);
- WritePS (mpPageBody, pPSCommand);
+ WritePS (mpPageBody, pPSCommand.makeStringAndClear());
}
void
@@ -918,14 +911,13 @@ void
PrinterGfx::PSBinPath (const Point& rCurrent, Point& rOld,
pspath_t eType, sal_Int32& nColumn)
{
- sal_Char pPath[48] = {0};
+ OStringBuffer pPath;
sal_Int32 nChar;
// create the hex representation of the dx and dy path shift, store the field
// width as it is needed for the building the command
- sal_Int32 nXPrec = getAlignedHexValueOf (rCurrent.X() - rOld.X(), pPath + 1);
- sal_Int32 nYPrec = getAlignedHexValueOf (rCurrent.Y() - rOld.Y(), pPath + 1 + nXPrec);
- pPath [ 1 + nXPrec + nYPrec ] = 0;
+ sal_Int32 nXPrec = getAlignedHexValueOf (rCurrent.X() - rOld.X(), pPath);
+ sal_Int32 nYPrec = getAlignedHexValueOf (rCurrent.Y() - rOld.Y(), pPath);
// build the command, it is a char with bit represention 000cxxyy
// c represents the char, xx and yy repr. the field width of the dx and dy shift,
@@ -948,7 +940,8 @@ PrinterGfx::PSBinPath (const Point& rCurrent, Point& rOld,
default: OSL_FAIL("invalid y precision in binary path");
}
cCmd += 'A';
- pPath[0] = cCmd;
+ pPath.insert(0, cCmd);
+ auto const path = pPath.makeStringAndClear();
// write the command to file,
// line breaking at column nMaxTextColumn (80)
@@ -957,15 +950,15 @@ PrinterGfx::PSBinPath (const Point& rCurrent, Point& rOld,
{
sal_Int32 nSegment = nMaxTextColumn - nColumn;
- WritePS (mpPageBody, pPath, nSegment);
+ WritePS (mpPageBody, path.copy(0, nSegment));
WritePS (mpPageBody, "\n", 1);
- WritePS (mpPageBody, pPath + nSegment, nChar - nSegment);
+ WritePS (mpPageBody, path.copy(nSegment));
nColumn = nChar - nSegment;
}
else
{
- WritePS (mpPageBody, pPath, nChar);
+ WritePS (mpPageBody, path);
nColumn += nChar;
}
@@ -976,22 +969,21 @@ PrinterGfx::PSBinPath (const Point& rCurrent, Point& rOld,
void
PrinterGfx::PSScale (double fScaleX, double fScaleY)
{
- sal_Char pScale [48];
- sal_Int32 nChar = 0;
+ OStringBuffer pScale;
- nChar = psp::getValueOfDouble (pScale, fScaleX, 5);
- nChar += psp::appendStr (" ", pScale + nChar);
- nChar += psp::getValueOfDouble (pScale + nChar, fScaleY, 5);
- nChar += psp::appendStr (" scale\n", pScale + nChar);
+ psp::getValueOfDouble (pScale, fScaleX, 5);
+ psp::appendStr (" ", pScale);
+ psp::getValueOfDouble (pScale, fScaleY, 5);
+ psp::appendStr (" scale\n", pScale);
- WritePS (mpPageBody, pScale, nChar);
+ WritePS (mpPageBody, pScale.makeStringAndClear());
}
/* psshowtext helper routines: draw an hex string for show/xshow */
void
PrinterGfx::PSHexString (const unsigned char* pString, sal_Int16 nLen)
{
- sal_Char pHexString [128];
+ OStringBuffer pHexString;
sal_Int32 nChar = 0;
nChar = psp::appendStr ("<", pHexString);
@@ -999,15 +991,15 @@ PrinterGfx::PSHexString (const unsigned char* pString, sal_Int16 nLen)
{
if (nChar >= (nMaxTextColumn - 1))
{
- nChar += psp::appendStr ("\n", pHexString + nChar);
- WritePS (mpPageBody, pHexString, nChar);
+ nChar += psp::appendStr ("\n", pHexString);
+ WritePS (mpPageBody, pHexString.makeStringAndClear());
nChar = 0;
}
- nChar += psp::getHexValueOf (static_cast<sal_Int32>(pString[i]), pHexString + nChar);
+ nChar += psp::getHexValueOf (static_cast<sal_Int32>(pString[i]), pHexString);
}
- nChar += psp::appendStr (">\n", pHexString + nChar);
- WritePS (mpPageBody, pHexString, nChar);
+ nChar += psp::appendStr (">\n", pHexString);
+ WritePS (mpPageBody, pHexString.makeStringAndClear());
}
void
diff --git a/vcl/unx/generic/print/printerjob.cxx b/vcl/unx/generic/print/printerjob.cxx
index ba68913619f9..7cf15556476e 100644
--- a/vcl/unx/generic/print/printerjob.cxx
+++ b/vcl/unx/generic/print/printerjob.cxx
@@ -362,12 +362,11 @@ PrinterJob::StartJob (
}
// Language Level
- sal_Char pLevel[16];
- sal_Int32 nSz = getValueOf(GetPostscriptLevel(&rSetupData), pLevel);
- pLevel[nSz++] = '\n';
- pLevel[nSz ] = '\0';
+ OStringBuffer pLevel;
+ getValueOf(GetPostscriptLevel(&rSetupData), pLevel);
+ pLevel.append('\n');
WritePS (mpJobHeader.get(), "%%LanguageLevel: ");
- WritePS (mpJobHeader.get(), pLevel);
+ WritePS (mpJobHeader.get(), pLevel.makeStringAndClear());
// Other
WritePS (mpJobHeader.get(), "%%DocumentData: Clean7Bit\n");
@@ -587,20 +586,19 @@ PrinterJob::StartPage (const JobData& rJobSetup)
mnPortraits++;
}
- sal_Char pBBox [256];
- sal_Int32 nChar = 0;
+ OStringBuffer pBBox;
- nChar = psp::appendStr ("%%PageBoundingBox: ", pBBox);
- nChar += psp::getValueOf (mnLMarginPt, pBBox + nChar);
- nChar += psp::appendStr (" ", pBBox + nChar);
- nChar += psp::getValueOf (mnBMarginPt, pBBox + nChar);
- nChar += psp::appendStr (" ", pBBox + nChar);
- nChar += psp::getValueOf (mnWidthPt - mnRMarginPt, pBBox + nChar);
- nChar += psp::appendStr (" ", pBBox + nChar);
- nChar += psp::getValueOf (mnHeightPt - mnTMarginPt, pBBox + nChar);
- nChar += psp::appendStr ("\n", pBBox + nChar);
+ psp::appendStr ("%%PageBoundingBox: ", pBBox);
+ psp::getValueOf (mnLMarginPt, pBBox);
+ psp::appendStr (" ", pBBox);
+ psp::getValueOf (mnBMarginPt, pBBox);
+ psp::appendStr (" ", pBBox);
+ psp::getValueOf (mnWidthPt - mnRMarginPt, pBBox);
+ psp::appendStr (" ", pBBox);
+ psp::getValueOf (mnHeightPt - mnTMarginPt, pBBox);
+ psp::appendStr ("\n", pBBox);
- WritePS (pPageHeader, pBBox, nChar);
+ WritePS (pPageHeader, pBBox.makeStringAndClear());
/* #i7262# #i65491# write setup only before first page
* (to %%Begin(End)Setup, instead of %%Begin(End)PageSetup)
@@ -631,12 +629,11 @@ PrinterJob::EndPage ()
// copy page to paper and write page trailer according to DSC
- sal_Char pTrailer[256];
- sal_Int32 nChar = 0;
- nChar = psp::appendStr ("grestore grestore\n", pTrailer);
- nChar += psp::appendStr ("showpage\n", pTrailer + nChar);
- nChar += psp::appendStr ("%%PageTrailer\n\n", pTrailer + nChar);
- WritePS (pPageBody, pTrailer, nChar);
+ OStringBuffer pTrailer;
+ psp::appendStr ("grestore grestore\n", pTrailer);
+ psp::appendStr ("showpage\n", pTrailer);
+ psp::appendStr ("%%PageTrailer\n\n", pTrailer);
+ WritePS (pPageBody, pTrailer.makeStringAndClear());
// this page is done for now, close it to avoid having too many open fd's
@@ -750,39 +747,38 @@ bool PrinterJob::writePageSetup( osl::File* pFile, const JobData& rJob, bool bWr
bSuccess = writeFeatureList( pFile, rJob, false );
WritePS (pFile, "%%EndPageSetup\n");
- sal_Char pTranslate [128];
- sal_Int32 nChar = 0;
+ OStringBuffer pTranslate;
if( rJob.m_eOrientation == orientation::Portrait )
{
- nChar = psp::appendStr ("gsave\n[", pTranslate);
- nChar += psp::getValueOfDouble ( pTranslate + nChar, mfXScale, 5);
- nChar += psp::appendStr (" 0 0 ", pTranslate + nChar);
- nChar += psp::getValueOfDouble ( pTranslate + nChar, mfYScale, 5);
- nChar += psp::appendStr (" ", pTranslate + nChar);
- nChar += psp::getValueOf (mnRMarginPt, pTranslate + nChar);
- nChar += psp::appendStr (" ", pTranslate + nChar);
- nChar += psp::getValueOf (mnHeightPt-mnTMarginPt,
- pTranslate + nChar);
- nChar += psp::appendStr ("] concat\ngsave\n",
- pTranslate + nChar);
+ psp::appendStr ("gsave\n[", pTranslate);
+ psp::getValueOfDouble ( pTranslate, mfXScale, 5);
+ psp::appendStr (" 0 0 ", pTranslate);
+ psp::getValueOfDouble ( pTranslate, mfYScale, 5);
+ psp::appendStr (" ", pTranslate);
+ psp::getValueOf (mnRMarginPt, pTranslate);
+ psp::appendStr (" ", pTranslate);
+ psp::getValueOf (mnHeightPt-mnTMarginPt,
+ pTranslate);
+ psp::appendStr ("] concat\ngsave\n",
+ pTranslate);
}
else
{
- nChar = psp::appendStr ("gsave\n", pTranslate);
- nChar += psp::appendStr ("[ 0 ", pTranslate + nChar);
- nChar += psp::getValueOfDouble ( pTranslate + nChar, -mfYScale, 5);
- nChar += psp::appendStr (" ", pTranslate + nChar);
- nChar += psp::getValueOfDouble ( pTranslate + nChar, mfXScale, 5);
- nChar += psp::appendStr (" 0 ", pTranslate + nChar );
- nChar += psp::getValueOfDouble ( pTranslate + nChar, mnLMarginPt, 5 );
- nChar += psp::appendStr (" ", pTranslate + nChar);
- nChar += psp::getValueOf (mnBMarginPt, pTranslate + nChar );
- nChar += psp::appendStr ("] concat\ngsave\n",
- pTranslate + nChar);
+ psp::appendStr ("gsave\n", pTranslate);
+ psp::appendStr ("[ 0 ", pTranslate);
+ psp::getValueOfDouble ( pTranslate, -mfYScale, 5);
+ psp::appendStr (" ", pTranslate);
+ psp::getValueOfDouble ( pTranslate, mfXScale, 5);
+ psp::appendStr (" 0 ", pTranslate );
+ psp::getValueOfDouble ( pTranslate, mnLMarginPt, 5 );
+ psp::appendStr (" ", pTranslate);
+ psp::getValueOf (mnBMarginPt, pTranslate );
+ psp::appendStr ("] concat\ngsave\n",
+ pTranslate);
}
- WritePS (pFile, pTranslate, nChar);
+ WritePS (pFile, pTranslate.makeStringAndClear());
return bSuccess;
}
diff --git a/vcl/unx/generic/print/psputil.cxx b/vcl/unx/generic/print/psputil.cxx
index 0026ccfac43f..4658865ed028 100644
--- a/vcl/unx/generic/print/psputil.cxx
+++ b/vcl/unx/generic/print/psputil.cxx
@@ -28,20 +28,20 @@ namespace psp {
*/
sal_Int32
-getHexValueOf (sal_Int32 nValue, sal_Char* pBuffer)
+getHexValueOf (sal_Int32 nValue, OStringBuffer& pBuffer)
{
const static sal_Char pHex [0x10] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
- pBuffer[0] = pHex [(nValue & 0xF0) >> 4];
- pBuffer[1] = pHex [(nValue & 0x0F) ];
+ pBuffer.append(pHex [(nValue & 0xF0) >> 4]);
+ pBuffer.append(pHex [(nValue & 0x0F) ]);
return 2;
}
sal_Int32
-getAlignedHexValueOf (sal_Int32 nValue, sal_Char* pBuffer)
+getAlignedHexValueOf (sal_Int32 nValue, OStringBuffer& pBuffer)
{
// get sign
bool bNegative = nValue < 0;
@@ -62,25 +62,28 @@ getAlignedHexValueOf (sal_Int32 nValue, sal_Char* pBuffer)
// convert the int into its hex representation, write it into the buffer
sal_Int32 nRet = nPrecision;
+ auto const start = pBuffer.getLength();
while (nPrecision)
{
- nPrecision -= getHexValueOf (nValue % 256, pBuffer + nPrecision - 2 );
+ OStringBuffer scratch;
+ nPrecision -= getHexValueOf (nValue % 256, scratch );
+ pBuffer.insert(start, scratch.makeStringAndClear());
nValue /= 256;
}
// set sign bit
if (bNegative)
{
- switch (pBuffer[0])
+ switch (pBuffer[start])
{
- case '0' : pBuffer[0] = '8'; break;
- case '1' : pBuffer[0] = '9'; break;
- case '2' : pBuffer[0] = 'A'; break;
- case '3' : pBuffer[0] = 'B'; break;
- case '4' : pBuffer[0] = 'C'; break;
- case '5' : pBuffer[0] = 'D'; break;
- case '6' : pBuffer[0] = 'E'; break;
- case '7' : pBuffer[0] = 'F'; break;
+ case '0' : pBuffer[start] = '8'; break;
+ case '1' : pBuffer[start] = '9'; break;
+ case '2' : pBuffer[start] = 'A'; break;
+ case '3' : pBuffer[start] = 'B'; break;
+ case '4' : pBuffer[start] = 'C'; break;
+ case '5' : pBuffer[start] = 'D'; break;
+ case '6' : pBuffer[start] = 'E'; break;
+ case '7' : pBuffer[start] = 'F'; break;
default: OSL_FAIL("Already a signed value");
}
}
@@ -90,18 +93,20 @@ getAlignedHexValueOf (sal_Int32 nValue, sal_Char* pBuffer)
}
sal_Int32
-getValueOf (sal_Int32 nValue, sal_Char* pBuffer)
+getValueOf (sal_Int32 nValue, OStringBuffer& pBuffer)
{
sal_Int32 nChar = 0;
if (nValue < 0)
{
- pBuffer [nChar++] = '-';
+ pBuffer.append('-');
+ ++nChar;
nValue *= -1;
}
else
if (nValue == 0)
{
- pBuffer [nChar++] = '0';
+ pBuffer.append('0');
+ ++nChar;
return nChar;
}
@@ -114,17 +119,18 @@ getValueOf (sal_Int32 nValue, sal_Char* pBuffer)
}
while (nInvChar > 0)
{
- pBuffer [nChar++] = pInvBuffer [--nInvChar];
+ pBuffer.append(pInvBuffer [--nInvChar]);
+ ++nChar;
}
return nChar;
}
sal_Int32
-appendStr (const sal_Char* pSrc, sal_Char* pDst)
+appendStr (const sal_Char* pSrc, OStringBuffer& pDst)
{
sal_Int32 nBytes = strlen (pSrc);
- strncpy (pDst, pSrc, nBytes + 1);
+ pDst.append(pSrc, nBytes);
return nBytes;
}
diff --git a/vcl/unx/generic/print/psputil.hxx b/vcl/unx/generic/print/psputil.hxx
index 1e58820bee16..ae3d78a730de 100644
--- a/vcl/unx/generic/print/psputil.hxx
+++ b/vcl/unx/generic/print/psputil.hxx
@@ -22,7 +22,9 @@
#include <osl/file.hxx>
+#include <rtl/math.hxx>
#include <rtl/ustring.hxx>
+#include <rtl/strbuf.hxx>
#include <rtl/string.hxx>
#include <rtl/tencinfo.h>
#include <rtl/textcvt.h>
@@ -33,13 +35,16 @@ namespace psp {
/*
* string convenience routines
- * sizeof(pBuffer) must be at least 2 Bytes, 0x00 <= nValue <= 0xFF,
- * effective buffer of get*ValueOf() is NOT NULL-terminated
*/
-sal_Int32 getHexValueOf (sal_Int32 nValue, sal_Char* pBuffer);
-sal_Int32 getAlignedHexValueOf (sal_Int32 nValue, sal_Char* pBuffer);
-sal_Int32 getValueOf (sal_Int32 nValue, sal_Char* pBuffer);
-sal_Int32 appendStr (const sal_Char* pSrc, sal_Char* pDst);
+sal_Int32 getHexValueOf (sal_Int32 nValue, OStringBuffer& pBuffer);
+sal_Int32 getAlignedHexValueOf (sal_Int32 nValue, OStringBuffer& pBuffer);
+sal_Int32 getValueOf (sal_Int32 nValue, OStringBuffer& pBuffer);
+sal_Int32 appendStr (const sal_Char* pSrc, OStringBuffer& pDst);
+
+inline void getValueOfDouble( OStringBuffer& pBuffer, double f, int nPrecision = 0)
+{
+ pBuffer.append(rtl::math::doubleToString( f, rtl_math_StringFormat_G, nPrecision, '.', true ));
+}
bool WritePS (osl::File* pFile, const sal_Char* pString);
bool WritePS (osl::File* pFile, const sal_Char* pString, sal_uInt64 nInLength);
More information about the Libreoffice-commits
mailing list