silence coverity unchecked return value from library on xmlText* functions

Change-Id: I651abb00d8ae1bdbf758a6a0176fd8912531a585
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/112753
Tested-by: Caolán McNamara <caolanm@redhat.com>
Reviewed-by: Caolán McNamara <caolanm@redhat.com>

89 files changed, 1464 insertions, 1462 deletions

diff --git a/chart2/source/model/main/ChartModel.cxx b/chart2/source/model/main/ChartModel.cxx
index 47684b21f060..164daeed7c3d 100644
--- a/chart2/source/model/main/ChartModel.cxx
+++ b/chart2/source/model/main/ChartModel.cxx
@@ -741,15 +741,15 @@ void ChartModel::removeDataProviders()
 
 void ChartModel::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("ChartModel"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("ChartModel"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
     if (mxChartView.is())
     {
         mxChartView->dumpAsXml(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 sal_Bool SAL_CALL ChartModel::hasInternalDataProvider()
diff --git a/chart2/source/view/main/ChartView.cxx b/chart2/source/view/main/ChartView.cxx
index 41a9aaa00393..89e59616dab4 100644
--- a/chart2/source/view/main/ChartView.cxx
+++ b/chart2/source/view/main/ChartView.cxx
@@ -2892,15 +2892,15 @@ OUString ChartView::dump()
 
 void ChartView::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("ChartView"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("ChartView"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
     if (m_pDrawModelWrapper)
     {
         m_pDrawModelWrapper->dumpAsXml(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void ChartView::setViewDirty()
diff --git a/chart2/source/view/main/DrawModelWrapper.cxx b/chart2/source/view/main/DrawModelWrapper.cxx
index c581b3871300..68ffac559a25 100644
--- a/chart2/source/view/main/DrawModelWrapper.cxx
+++ b/chart2/source/view/main/DrawModelWrapper.cxx
@@ -328,12 +328,12 @@ bool DrawModelWrapper::removeShape( const uno::Reference< drawing::XShape >& xSh
 
 void DrawModelWrapper::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("DrawModelWrapper"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("DrawModelWrapper"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
     SdrModel::dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 } //namespace chart
diff --git a/drawinglayer/source/dumper/EnhancedShapeDumper.cxx b/drawinglayer/source/dumper/EnhancedShapeDumper.cxx
index 611ac87cd33d..1d453e32aad0 100644
--- a/drawinglayer/source/dumper/EnhancedShapeDumper.cxx
+++ b/drawinglayer/source/dumper/EnhancedShapeDumper.cxx
@@ -160,109 +160,109 @@ void EnhancedShapeDumper::dumpEnhancedCustomShapeExtrusionService(const uno::Ref
 void EnhancedShapeDumper::dumpExtrusionAsAttribute(bool bExtrusion)
 {
     if(bExtrusion)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusion"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusion"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusion"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusion"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpBrightnessAsAttribute(double aBrightness)
 {
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("brightness"), "%f", aBrightness);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("brightness"), "%f", aBrightness);
 }
 
 void EnhancedShapeDumper::dumpEnhancedCustomShapeParameterPair(
     const drawing::EnhancedCustomShapeParameterPair& aParameterPair)
 {
     {
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "First" ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "First" ));
         dumpEnhancedCustomShapeParameter(aParameterPair.First);
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterEndElement( xmlWriter );
     }
     {
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Second" ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Second" ));
         dumpEnhancedCustomShapeParameter(aParameterPair.Second);
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterEndElement( xmlWriter );
     }
 }
 
 void EnhancedShapeDumper::dumpDepthAsElement(const drawing::EnhancedCustomShapeParameterPair& aDepth)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Depth" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Depth" ));
     dumpEnhancedCustomShapeParameterPair(aDepth);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpDiffusionAsAttribute(double aDiffusion)
 {
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("diffusion"), "%f", aDiffusion);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("diffusion"), "%f", aDiffusion);
 }
 
 void EnhancedShapeDumper::dumpNumberOfLineSegmentsAsAttribute(sal_Int32 aNumberOfLineSegments)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("numberOfLineSegments"), "%" SAL_PRIdINT32, aNumberOfLineSegments);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("numberOfLineSegments"), "%" SAL_PRIdINT32, aNumberOfLineSegments);
 }
 
 void EnhancedShapeDumper::dumpLightFaceAsAttribute(bool bLightFace)
 {
     if(bLightFace)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lightFace"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lightFace"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lightFace"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lightFace"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpFirstLightHarshAsAttribute(bool bFirstLightHarsh)
 {
     if(bFirstLightHarsh)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("firstLightHarsh"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("firstLightHarsh"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("firstLightHarsh"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("firstLightHarsh"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpSecondLightHarshAsAttribute(bool bSecondLightHarsh)
 {
     if(bSecondLightHarsh)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("secondLightHarsh"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("secondLightHarsh"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("secondLightHarsh"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("secondLightHarsh"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpFirstLightLevelAsAttribute(double aFirstLightLevel)
 {
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("firstLightLevel"), "%f", aFirstLightLevel);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("firstLightLevel"), "%f", aFirstLightLevel);
 }
 
 void EnhancedShapeDumper::dumpSecondLightLevelAsAttribute(double aSecondLightLevel)
 {
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("secondLightLevel"), "%f", aSecondLightLevel);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("secondLightLevel"), "%f", aSecondLightLevel);
 }
 
 void EnhancedShapeDumper::dumpDirection3D(drawing::Direction3D aDirection3D)
 {
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("directionX"), "%f", aDirection3D.DirectionX);
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("directionY"), "%f", aDirection3D.DirectionY);
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("directionZ"), "%f", aDirection3D.DirectionZ);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("directionX"), "%f", aDirection3D.DirectionX);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("directionY"), "%f", aDirection3D.DirectionY);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("directionZ"), "%f", aDirection3D.DirectionZ);
 }
 
 void EnhancedShapeDumper::dumpFirstLightDirectionAsElement(drawing::Direction3D aFirstLightDirection)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "FirstLightDirection" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "FirstLightDirection" ));
     dumpDirection3D(aFirstLightDirection);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpSecondLightDirectionAsElement(drawing::Direction3D aSecondLightDirection)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "SecondLightDirection" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "SecondLightDirection" ));
     dumpDirection3D(aSecondLightDirection);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpMetalAsAttribute(bool bMetal)
 {
     if(bMetal)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("metal"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("metal"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("metal"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("metal"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpShadeModeAsAttribute(drawing::ShadeMode eShadeMode)
@@ -270,16 +270,16 @@ void EnhancedShapeDumper::dumpShadeModeAsAttribute(drawing::ShadeMode eShadeMode
     switch(eShadeMode)
     {
         case drawing::ShadeMode_FLAT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "FLAT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "FLAT");
             break;
         case drawing::ShadeMode_PHONG:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "PHONG");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "PHONG");
             break;
         case drawing::ShadeMode_SMOOTH:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "SMOOTH");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "SMOOTH");
             break;
         case drawing::ShadeMode_DRAFT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "DRAFT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadeMode"), "%s", "DRAFT");
             break;
         default:
             break;
@@ -288,33 +288,33 @@ void EnhancedShapeDumper::dumpShadeModeAsAttribute(drawing::ShadeMode eShadeMode
 
 void EnhancedShapeDumper::dumpRotateAngleAsElement(const drawing::EnhancedCustomShapeParameterPair& aRotateAngle)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RotateAngle" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RotateAngle" ));
     dumpEnhancedCustomShapeParameterPair(aRotateAngle);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpRotationCenterAsElement(drawing::Direction3D aRotationCenter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RotationCenter" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RotationCenter" ));
     dumpDirection3D(aRotationCenter);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpShininessAsAttribute(double aShininess)
 {
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shininess"), "%f", aShininess);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shininess"), "%f", aShininess);
 }
 
 void EnhancedShapeDumper::dumpSkewAsElement(const drawing::EnhancedCustomShapeParameterPair& aSkew)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Skew" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Skew" ));
     dumpEnhancedCustomShapeParameterPair(aSkew);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpSpecularityAsAttribute(double aSpecularity)
 {
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("specularity"), "%f", aSpecularity);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("specularity"), "%f", aSpecularity);
 }
 
 void EnhancedShapeDumper::dumpProjectionModeAsAttribute(drawing::ProjectionMode eProjectionMode)
@@ -322,10 +322,10 @@ void EnhancedShapeDumper::dumpProjectionModeAsAttribute(drawing::ProjectionMode
     switch(eProjectionMode)
     {
         case drawing::ProjectionMode_PARALLEL:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("projectionMode"), "%s", "PARALLEL");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("projectionMode"), "%s", "PARALLEL");
             break;
         case drawing::ProjectionMode_PERSPECTIVE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("projectionMode"), "%s", "PERSPECTIVE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("projectionMode"), "%s", "PERSPECTIVE");
             break;
         default:
             break;
@@ -334,26 +334,26 @@ void EnhancedShapeDumper::dumpProjectionModeAsAttribute(drawing::ProjectionMode
 
 void EnhancedShapeDumper::dumpViewPointAsElement(drawing::Position3D aViewPoint)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "ViewPoint" ));
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("positionX"), "%f", aViewPoint.PositionX);
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("positionY"), "%f", aViewPoint.PositionY);
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("positionZ"), "%f", aViewPoint.PositionZ);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "ViewPoint" ));
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("positionX"), "%f", aViewPoint.PositionX);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("positionY"), "%f", aViewPoint.PositionY);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("positionZ"), "%f", aViewPoint.PositionZ);
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpOriginAsElement(const drawing::EnhancedCustomShapeParameterPair& aOrigin)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Origin" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Origin" ));
     dumpEnhancedCustomShapeParameterPair(aOrigin);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpExtrusionColorAsAttribute(bool bExtrusionColor)
 {
     if(bExtrusionColor)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionColor"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionColor"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionColor"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionColor"), "%s", "false");
 }
 
 
@@ -431,48 +431,48 @@ void EnhancedShapeDumper::dumpEnhancedCustomShapeGeometryService(const uno::Refe
 }
 void EnhancedShapeDumper::dumpTypeAsAttribute(std::u16string_view sType)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("type"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("type"), "%s",
         OUStringToOString(sType, RTL_TEXTENCODING_UTF8).getStr());
 }
 
 void EnhancedShapeDumper::dumpViewBoxAsElement(awt::Rectangle aViewBox)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "ViewBox" ));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("x"), "%" SAL_PRIdINT32, aViewBox.X);
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("y"), "%" SAL_PRIdINT32, aViewBox.Y);
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("width"), "%" SAL_PRIdINT32, aViewBox.Width);
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("height"), "%" SAL_PRIdINT32, aViewBox.Height);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "ViewBox" ));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("x"), "%" SAL_PRIdINT32, aViewBox.X);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("y"), "%" SAL_PRIdINT32, aViewBox.Y);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("width"), "%" SAL_PRIdINT32, aViewBox.Width);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("height"), "%" SAL_PRIdINT32, aViewBox.Height);
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpMirroredXAsAttribute(bool bMirroredX)
 {
     if(bMirroredX)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredX"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredX"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredX"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredX"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpMirroredYAsAttribute(bool bMirroredY)
 {
     if(bMirroredY)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredY"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredY"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredY"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("mirroredY"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpTextRotateAngleAsAttribute(double aTextRotateAngle)
 {
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textRotateAngle"), "%f", aTextRotateAngle);
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textRotateAngle"), "%f", aTextRotateAngle);
 }
 
 void EnhancedShapeDumper::dumpAdjustmentValuesAsElement(const uno::Sequence< drawing::EnhancedCustomShapeAdjustmentValue>& aAdjustmentValues)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "AdjustmentValues" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "AdjustmentValues" ));
     sal_Int32 nLength = aAdjustmentValues.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
     {
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeAdjustmentValue" ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeAdjustmentValue" ));
         uno::Any aAny = aAdjustmentValues[i].Value;
         OUString sValue;
         float fValue;
@@ -480,116 +480,116 @@ void EnhancedShapeDumper::dumpAdjustmentValuesAsElement(const uno::Sequence< dra
         bool bValue;
         if(aAny >>= sValue)
         {
-            xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s",
+            (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s",
                 OUStringToOString(sValue, RTL_TEXTENCODING_UTF8).getStr());
         }
         else if(aAny >>= nValue)
         {
-            xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%" SAL_PRIdINT32, nValue);
+            (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%" SAL_PRIdINT32, nValue);
         }
         else if(aAny >>= fValue)
         {
-            xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%f", fValue);
+            (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%f", fValue);
         }
         else if(aAny >>= bValue)
         {
-            xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s", (bValue? "true": "false"));
+            (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s", (bValue? "true": "false"));
         }
 
         switch(aAdjustmentValues[i].State)
         {
             case beans::PropertyState_DIRECT_VALUE:
-                xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DIRECT_VALUE");
+                (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DIRECT_VALUE");
                 break;
             case beans::PropertyState_DEFAULT_VALUE:
-                xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DEFAULT_VALUE");
+                (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DEFAULT_VALUE");
                 break;
             case beans::PropertyState_AMBIGUOUS_VALUE:
-                xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "AMBIGUOUS_VALUE");
+                (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "AMBIGUOUS_VALUE");
                 break;
             default:
                 break;
         }
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterEndElement( xmlWriter );
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpPropertyValueAsElement(const beans::PropertyValue& aPropertyValue)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "PropertyValue" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "PropertyValue" ));
 
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("name"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("name"), "%s",
         OUStringToOString(aPropertyValue.Name, RTL_TEXTENCODING_UTF8).getStr());
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("handle"), "%" SAL_PRIdINT32, aPropertyValue.Handle);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("handle"), "%" SAL_PRIdINT32, aPropertyValue.Handle);
 
     uno::Any aAny = aPropertyValue.Value;
     OUString sValue;
     if(aAny >>= sValue)
     {
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s",
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s",
             OUStringToOString(sValue, RTL_TEXTENCODING_UTF8).getStr());
     }
     switch(aPropertyValue.State)
     {
         case beans::PropertyState_DIRECT_VALUE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DIRECT_VALUE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DIRECT_VALUE");
             break;
         case beans::PropertyState_DEFAULT_VALUE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DEFAULT_VALUE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DEFAULT_VALUE");
             break;
         case beans::PropertyState_AMBIGUOUS_VALUE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "AMBIGUOUS_VALUE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "AMBIGUOUS_VALUE");
             break;
         default:
             break;
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpExtrusionAsElement(const uno::Sequence< beans::PropertyValue >& aExtrusion)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Extrusion" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Extrusion" ));
     sal_Int32 nLength = aExtrusion.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
     {
         dumpPropertyValueAsElement(aExtrusion[i]);
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpPathAsElement(const uno::Sequence< beans::PropertyValue >& aPath)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Path" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Path" ));
     sal_Int32 nLength = aPath.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
     {
         dumpPropertyValueAsElement(aPath[i]);
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpTextPathAsElement(const uno::Sequence< beans::PropertyValue >& aTextPath)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "TextPath" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "TextPath" ));
     sal_Int32 nLength = aTextPath.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
     {
         dumpPropertyValueAsElement(aTextPath[i]);
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpEquationsAsElement(const uno::Sequence< OUString >& aEquations)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Equations" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Equations" ));
     sal_Int32 nLength = aEquations.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
     {
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("name"), "%s",
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("name"), "%s",
             OUStringToOString(aEquations[i], RTL_TEXTENCODING_UTF8).getStr());
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 // PropertyValues specifies a sequence of PropertyValue instances.
@@ -597,20 +597,20 @@ void EnhancedShapeDumper::dumpEquationsAsElement(const uno::Sequence< OUString >
 // Welcome to Sequenception again.
 void EnhancedShapeDumper::dumpHandlesAsElement(const uno::Sequence< beans::PropertyValues >& aHandles)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Handles" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Handles" ));
     sal_Int32 nSequenceLength = aHandles.getLength();
     for (sal_Int32 i = 0; i < nSequenceLength; ++i)
     {
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "PropertyValues" ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "PropertyValues" ));
         uno::Sequence< beans::PropertyValue > propertyValueSequence = aHandles[i];
         sal_Int32 nLength = propertyValueSequence.getLength();
         for (sal_Int32 j = 0; j < nLength; ++j)
         {
             dumpPropertyValueAsElement(propertyValueSequence[j]);
         }
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterEndElement( xmlWriter );
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 
@@ -714,43 +714,43 @@ void EnhancedShapeDumper::dumpEnhancedCustomShapeHandleService(const uno::Refere
 void EnhancedShapeDumper::dumpSwitchedAsAttribute(bool bSwitched)
 {
     if(bSwitched)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("switched"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("switched"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("switched"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("switched"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpPositionAsElement(const drawing::EnhancedCustomShapeParameterPair& aPosition)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Position" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Position" ));
     dumpEnhancedCustomShapeParameterPair(aPosition);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpPolarAsElement(const drawing::EnhancedCustomShapeParameterPair& aPolar)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Polar" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Polar" ));
     dumpEnhancedCustomShapeParameterPair(aPolar);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpRefXAsAttribute(sal_Int32 aRefX)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refX"), "%" SAL_PRIdINT32, aRefX);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refX"), "%" SAL_PRIdINT32, aRefX);
 }
 
 void EnhancedShapeDumper::dumpRefYAsAttribute(sal_Int32 aRefY)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refY"), "%" SAL_PRIdINT32, aRefY);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refY"), "%" SAL_PRIdINT32, aRefY);
 }
 
 void EnhancedShapeDumper::dumpRefAngleAsAttribute(sal_Int32 aRefAngle)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refAngle"), "%" SAL_PRIdINT32, aRefAngle);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refAngle"), "%" SAL_PRIdINT32, aRefAngle);
 }
 
 void EnhancedShapeDumper::dumpRefRAsAttribute(sal_Int32 aRefR)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refR"), "%" SAL_PRIdINT32, aRefR);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("refR"), "%" SAL_PRIdINT32, aRefR);
 }
 
 void EnhancedShapeDumper::dumpEnhancedCustomShapeParameter(
@@ -763,65 +763,65 @@ void EnhancedShapeDumper::dumpEnhancedCustomShapeParameter(
     bool bValue;
     if(aAny >>= sValue)
     {
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s",
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s",
             OUStringToOString(sValue, RTL_TEXTENCODING_UTF8).getStr());
     }
     else if(aAny >>= nValue)
     {
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%" SAL_PRIdINT32, nValue);
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%" SAL_PRIdINT32, nValue);
     }
     else if(aAny >>= fValue)
     {
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%f", fValue);
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%f", fValue);
     }
     else if(aAny >>= bValue)
     {
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s", (bValue? "true": "false"));
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s", (bValue? "true": "false"));
     }
     sal_Int32 aType = aParameter.Type;
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("type"), "%" SAL_PRIdINT32, aType);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("type"), "%" SAL_PRIdINT32, aType);
 }
 
 void EnhancedShapeDumper::dumpRangeXMinimumAsElement(const drawing::EnhancedCustomShapeParameter& aRangeXMinimum)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeXMinimum" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeXMinimum" ));
     dumpEnhancedCustomShapeParameter(aRangeXMinimum);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpRangeXMaximumAsElement(const drawing::EnhancedCustomShapeParameter& aRangeXMaximum)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeXMaximum" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeXMaximum" ));
     dumpEnhancedCustomShapeParameter(aRangeXMaximum);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpRangeYMinimumAsElement(const drawing::EnhancedCustomShapeParameter& aRangeYMinimum)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeYMinimum" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeYMinimum" ));
     dumpEnhancedCustomShapeParameter(aRangeYMinimum);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpRangeYMaximumAsElement(const drawing::EnhancedCustomShapeParameter& aRangeYMaximum)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeYMaximum" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RangeYMaximum" ));
     dumpEnhancedCustomShapeParameter(aRangeYMaximum);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpRadiusRangeMinimumAsElement(const drawing::EnhancedCustomShapeParameter& aRadiusRangeMinimum)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RadiusRangeMinimum" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RadiusRangeMinimum" ));
     dumpEnhancedCustomShapeParameter(aRadiusRangeMinimum);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpRadiusRangeMaximumAsElement(const drawing::EnhancedCustomShapeParameter& aRadiusRangeMaximum)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RadiusRangeMaximum" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "RadiusRangeMaximum" ));
     dumpEnhancedCustomShapeParameter(aRadiusRangeMaximum);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 
@@ -906,129 +906,129 @@ void EnhancedShapeDumper::dumpEnhancedCustomShapePathService(const uno::Referenc
 
 void EnhancedShapeDumper::dumpCoordinatesAsElement(const uno::Sequence< drawing::EnhancedCustomShapeParameterPair >& aCoordinates)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Coordinates" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Coordinates" ));
     sal_Int32 nLength = aCoordinates.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
     {
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeParameterPair" ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeParameterPair" ));
         dumpEnhancedCustomShapeParameterPair(aCoordinates[i]);
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterEndElement( xmlWriter );
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpSegmentsAsElement(const uno::Sequence< drawing::EnhancedCustomShapeSegment >& aSegments)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Segments" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Segments" ));
     sal_Int32 nLength = aSegments.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
     {
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeSegment" ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeSegment" ));
         sal_Int32 aCommand = aSegments[i].Command;
         sal_Int32 aCount = aSegments[i].Count;
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("command"), "%" SAL_PRIdINT32, aCommand);
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("count"), "%" SAL_PRIdINT32, aCount);
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("command"), "%" SAL_PRIdINT32, aCommand);
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("count"), "%" SAL_PRIdINT32, aCount);
+        (void)xmlTextWriterEndElement( xmlWriter );
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpStretchXAsAttribute(sal_Int32 aStretchX)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("stretchX"), "%" SAL_PRIdINT32, aStretchX);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("stretchX"), "%" SAL_PRIdINT32, aStretchX);
 }
 
 void EnhancedShapeDumper::dumpStretchYAsAttribute(sal_Int32 aStretchY)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("stretchY"), "%" SAL_PRIdINT32, aStretchY);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("stretchY"), "%" SAL_PRIdINT32, aStretchY);
 }
 
 void EnhancedShapeDumper::dumpTextFramesAsElement(const uno::Sequence< drawing::EnhancedCustomShapeTextFrame >& aTextFrames)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "TextFrames" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "TextFrames" ));
     sal_Int32 nLength = aTextFrames.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
     {
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeTextFrame" ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeTextFrame" ));
         {
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "TopLeft" ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "TopLeft" ));
         dumpEnhancedCustomShapeParameterPair(aTextFrames[i].TopLeft);
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterEndElement( xmlWriter );
 
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "BottomRight" ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "BottomRight" ));
         dumpEnhancedCustomShapeParameterPair(aTextFrames[i].BottomRight);
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterEndElement( xmlWriter );
         }
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterEndElement( xmlWriter );
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpGluePointsAsElement(const uno::Sequence< drawing::EnhancedCustomShapeParameterPair >& aGluePoints)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "GluePoints" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "GluePoints" ));
     sal_Int32 nLength = aGluePoints.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
     {
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeParameterPair" ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "EnhancedCustomShapeParameterPair" ));
         dumpEnhancedCustomShapeParameterPair(aGluePoints[i]);
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterEndElement( xmlWriter );
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpGluePointLeavingDirectionsAsElement(const uno::Sequence< double >& aGluePointLeavingDirections)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "GluePointLeavingDirections" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "GluePointLeavingDirections" ));
     sal_Int32 nLength = aGluePointLeavingDirections.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
     {
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("value"), "%f", aGluePointLeavingDirections[i]);
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("value"), "%f", aGluePointLeavingDirections[i]);
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void EnhancedShapeDumper::dumpGluePointTypeAsAttribute(sal_Int32 aGluePointType)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("gluePointType"), "%" SAL_PRIdINT32, aGluePointType);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("gluePointType"), "%" SAL_PRIdINT32, aGluePointType);
 }
 
 void EnhancedShapeDumper::dumpExtrusionAllowedAsAttribute(bool bExtrusionAllowed)
 {
     if(bExtrusionAllowed)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionAllowed"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionAllowed"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionAllowed"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("extrusionAllowed"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpConcentricGradientFillAllowedAsAttribute(bool bConcentricGradientFillAllowed)
 {
     if(bConcentricGradientFillAllowed)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("concentricGradientFillAllowed"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("concentricGradientFillAllowed"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("concentricGradientFillAllowed"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("concentricGradientFillAllowed"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpTextPathAllowedAsAttribute(bool bTextPathAllowed)
 {
     if(bTextPathAllowed)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathAllowed"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathAllowed"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathAllowed"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathAllowed"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpSubViewSizeAsElement(const uno::Sequence< awt::Size >& aSubViewSize)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "SubViewSize" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "SubViewSize" ));
     sal_Int32 nLength = aSubViewSize.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
     {
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Size" ));
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("width"), "%" SAL_PRIdINT32, aSubViewSize[i].Width);
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("height"), "%" SAL_PRIdINT32, aSubViewSize[i].Height);
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Size" ));
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("width"), "%" SAL_PRIdINT32, aSubViewSize[i].Width);
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("height"), "%" SAL_PRIdINT32, aSubViewSize[i].Height);
+        (void)xmlTextWriterEndElement( xmlWriter );
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 
@@ -1060,9 +1060,9 @@ void EnhancedShapeDumper::dumpEnhancedCustomShapeTextPathService(const uno::Refe
 void EnhancedShapeDumper::dumpTextPathAsAttribute(bool bTextPath)
 {
     if(bTextPath)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPath"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPath"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPath"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPath"), "%s", "false");
 }
 
 void EnhancedShapeDumper::dumpTextPathModeAsAttribute(drawing::EnhancedCustomShapeTextPathMode eTextPathMode)
@@ -1070,13 +1070,13 @@ void EnhancedShapeDumper::dumpTextPathModeAsAttribute(drawing::EnhancedCustomSha
     switch(eTextPathMode)
     {
         case drawing::EnhancedCustomShapeTextPathMode_NORMAL:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathMode"), "%s", "NORMAL");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathMode"), "%s", "NORMAL");
             break;
         case drawing::EnhancedCustomShapeTextPathMode_PATH:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathMode"), "%s", "PATH");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathMode"), "%s", "PATH");
             break;
         case drawing::EnhancedCustomShapeTextPathMode_SHAPE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathMode"), "%s", "SHAPE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textPathMode"), "%s", "SHAPE");
             break;
         default:
             break;
@@ -1086,9 +1086,9 @@ void EnhancedShapeDumper::dumpTextPathModeAsAttribute(drawing::EnhancedCustomSha
 void EnhancedShapeDumper::dumpScaleXAsAttribute(bool bScaleX)
 {
     if(bScaleX)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("scaleX"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("scaleX"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("scaleX"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("scaleX"), "%s", "false");
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/dumper/XShapeDumper.cxx b/drawinglayer/source/dumper/XShapeDumper.cxx
index 5ea63dccc323..7e258dc40619 100644
--- a/drawinglayer/source/dumper/XShapeDumper.cxx
+++ b/drawinglayer/source/dumper/XShapeDumper.cxx
@@ -202,19 +202,19 @@ void dumpFillStyleAsAttribute(drawing::FillStyle eFillStyle, xmlTextWriterPtr xm
     switch(eFillStyle)
     {
         case drawing::FillStyle_NONE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillStyle"), "%s", "NONE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillStyle"), "%s", "NONE");
             break;
         case drawing::FillStyle_SOLID:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillStyle"), "%s", "SOLID");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillStyle"), "%s", "SOLID");
             break;
         case drawing::FillStyle_GRADIENT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillStyle"), "%s", "GRADIENT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillStyle"), "%s", "GRADIENT");
             break;
         case drawing::FillStyle_HATCH:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillStyle"), "%s", "HATCH");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillStyle"), "%s", "HATCH");
             break;
         case drawing::FillStyle_BITMAP:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillStyle"), "%s", "BITMAP");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillStyle"), "%s", "BITMAP");
             break;
         default:
             break;
@@ -223,17 +223,17 @@ void dumpFillStyleAsAttribute(drawing::FillStyle eFillStyle, xmlTextWriterPtr xm
 
 void dumpFillColorAsAttribute(sal_Int32 aColor, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillColor"), "%06x", static_cast<unsigned int>(aColor));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillColor"), "%06x", static_cast<unsigned int>(aColor));
 }
 
 void dumpFillTransparenceAsAttribute(sal_Int32 aTransparence, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillTransparence"), "%" SAL_PRIdINT32, aTransparence);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillTransparence"), "%" SAL_PRIdINT32, aTransparence);
 }
 
 void dumpFillTransparenceGradientNameAsAttribute(std::u16string_view sTranspGradName, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillTransparenceGradientName"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillTransparenceGradientName"), "%s",
         OUStringToOString(sTranspGradName, RTL_TEXTENCODING_UTF8).getStr());
 }
 
@@ -243,118 +243,118 @@ void dumpGradientProperty(const awt::Gradient& rGradient, xmlTextWriterPtr xmlWr
     switch (rGradient.Style)   //enum GradientStyle
     {
         case awt::GradientStyle_LINEAR:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "LINEAR");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "LINEAR");
             break;
         case awt::GradientStyle_AXIAL:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "AXIAL");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "AXIAL");
             break;
         case awt::GradientStyle_RADIAL:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "RADIAL");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "RADIAL");
             break;
         case awt::GradientStyle_ELLIPTICAL:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "ELLIPTICAL");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "ELLIPTICAL");
             break;
         case awt::GradientStyle_SQUARE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "SQUARE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "SQUARE");
             break;
         case awt::GradientStyle_RECT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "RECT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "RECT");
             break;
         default:
             break;
     }
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("startColor"), "%06x", static_cast<unsigned int>(rGradient.StartColor));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("endColor"), "%06x", static_cast<unsigned int>(rGradient.EndColor));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("angle"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.Angle));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("border"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.Border));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("xOffset"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.XOffset));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("yOffset"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.YOffset));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("startIntensity"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.StartIntensity));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("endIntensity"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.EndIntensity));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("stepCount"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.StepCount));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("startColor"), "%06x", static_cast<unsigned int>(rGradient.StartColor));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("endColor"), "%06x", static_cast<unsigned int>(rGradient.EndColor));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("angle"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.Angle));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("border"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.Border));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("xOffset"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.XOffset));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("yOffset"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.YOffset));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("startIntensity"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.StartIntensity));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("endIntensity"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.EndIntensity));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("stepCount"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rGradient.StepCount));
 }
 
 void dumpFillTransparenceGradientAsElement(const awt::Gradient& rTranspGrad, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "FillTransparenceGradient" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "FillTransparenceGradient" ));
     dumpGradientProperty(rTranspGrad, xmlWriter);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpFillGradientNameAsAttribute(std::u16string_view sGradName, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillGradientName"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillGradientName"), "%s",
         OUStringToOString(sGradName, RTL_TEXTENCODING_UTF8).getStr());
 }
 
 void dumpFillGradientAsElement(const awt::Gradient& rGradient, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "FillGradient" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "FillGradient" ));
     dumpGradientProperty(rGradient, xmlWriter);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpFillHatchAsElement(const drawing::Hatch& rHatch, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "FillHatch" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "FillHatch" ));
     switch (rHatch.Style)
     {
         case drawing::HatchStyle_SINGLE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "SINGLE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "SINGLE");
             break;
         case drawing::HatchStyle_DOUBLE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "DOUBLE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "DOUBLE");
             break;
         case drawing::HatchStyle_TRIPLE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "TRIPLE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "TRIPLE");
             break;
         default:
             break;
     }
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("color"), "%06x", static_cast<unsigned int>(rHatch.Color));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("distance"), "%" SAL_PRIdINT32, rHatch.Distance);
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("angle"), "%" SAL_PRIdINT32, rHatch.Angle);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("color"), "%06x", static_cast<unsigned int>(rHatch.Color));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("distance"), "%" SAL_PRIdINT32, rHatch.Distance);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("angle"), "%" SAL_PRIdINT32, rHatch.Angle);
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpFillBackgroundAsAttribute(bool bBackground, xmlTextWriterPtr xmlWriter)
 {
     if(bBackground)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBackground"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBackground"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBackground"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBackground"), "%s", "false");
 }
 
 void dumpFillBitmapAsElement(const uno::Reference<awt::XBitmap>& xBitmap, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "FillBitmap" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "FillBitmap" ));
     if (xBitmap.is())
     {
         awt::Size const aSize = xBitmap->getSize();
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("width"), "%" SAL_PRIdINT32, aSize.Width);
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("height"), "%" SAL_PRIdINT32, aSize.Height);
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("width"), "%" SAL_PRIdINT32, aSize.Width);
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("height"), "%" SAL_PRIdINT32, aSize.Height);
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpFillBitmapPositionOffsetXAsAttribute(sal_Int32 aBitmapPositionOffsetX, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapPositionOffsetX"), "%" SAL_PRIdINT32, aBitmapPositionOffsetX);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapPositionOffsetX"), "%" SAL_PRIdINT32, aBitmapPositionOffsetX);
 }
 
 void dumpFillBitmapPositionOffsetYAsAttribute(sal_Int32 aBitmapPositionOffsetY, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapPositionOffsetY"), "%" SAL_PRIdINT32, aBitmapPositionOffsetY);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapPositionOffsetY"), "%" SAL_PRIdINT32, aBitmapPositionOffsetY);
 }
 
 void dumpFillBitmapOffsetXAsAttribute(sal_Int32 aBitmapOffsetX, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapOffsetX"), "%" SAL_PRIdINT32, aBitmapOffsetX);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapOffsetX"), "%" SAL_PRIdINT32, aBitmapOffsetX);
 }
 
 void dumpFillBitmapOffsetYAsAttribute(sal_Int32 aBitmapOffsetY, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapOffsetY"), "%" SAL_PRIdINT32, aBitmapOffsetY);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapOffsetY"), "%" SAL_PRIdINT32, aBitmapOffsetY);
 }
 
 void dumpFillBitmapRectanglePointAsAttribute(drawing::RectanglePoint eBitmapRectanglePoint, xmlTextWriterPtr xmlWriter)
@@ -362,31 +362,31 @@ void dumpFillBitmapRectanglePointAsAttribute(drawing::RectanglePoint eBitmapRect
     switch(eBitmapRectanglePoint)
     {
         case drawing::RectanglePoint_LEFT_TOP:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "LEFT_TOP");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "LEFT_TOP");
             break;
         case drawing::RectanglePoint_MIDDLE_TOP:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "MIDDLE_TOP");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "MIDDLE_TOP");
             break;
         case drawing::RectanglePoint_RIGHT_TOP:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "RIGHT_TOP");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "RIGHT_TOP");
             break;
         case drawing::RectanglePoint_LEFT_MIDDLE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "LEFT_MIDDLE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "LEFT_MIDDLE");
             break;
         case drawing::RectanglePoint_MIDDLE_MIDDLE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "MIDDLE_MIDDLE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "MIDDLE_MIDDLE");
             break;
         case drawing::RectanglePoint_RIGHT_MIDDLE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "RIGHT_MIDDLE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "RIGHT_MIDDLE");
             break;
         case drawing::RectanglePoint_LEFT_BOTTOM:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "LEFT_BOTTOM");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "LEFT_BOTTOM");
             break;
         case drawing::RectanglePoint_MIDDLE_BOTTOM:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "MIDDLE_BOTTOM");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "MIDDLE_BOTTOM");
             break;
         case drawing::RectanglePoint_RIGHT_BOTTOM:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "RIGHT_BOTTOM");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapRectanglePoint"), "%s", "RIGHT_BOTTOM");
             break;
         default:
             break;
@@ -396,19 +396,19 @@ void dumpFillBitmapRectanglePointAsAttribute(drawing::RectanglePoint eBitmapRect
 void dumpFillBitmapLogicalSizeAsAttribute(bool bBitmapLogicalSize, xmlTextWriterPtr xmlWriter)
 {
     if(bBitmapLogicalSize)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapLogicalSize"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapLogicalSize"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapLogicalSize"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapLogicalSize"), "%s", "false");
 }
 
 void dumpFillBitmapSizeXAsAttribute(sal_Int32 aBitmapSizeX, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapSizeX"), "%" SAL_PRIdINT32, aBitmapSizeX);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapSizeX"), "%" SAL_PRIdINT32, aBitmapSizeX);
 }
 
 void dumpFillBitmapSizeYAsAttribute(sal_Int32 aBitmapSizeY, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapSizeY"), "%" SAL_PRIdINT32, aBitmapSizeY);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fillBitmapSizeY"), "%" SAL_PRIdINT32, aBitmapSizeY);
 }
 
 void dumpFillBitmapModeAsAttribute(drawing::BitmapMode eBitmapMode, xmlTextWriterPtr xmlWriter)
@@ -416,13 +416,13 @@ void dumpFillBitmapModeAsAttribute(drawing::BitmapMode eBitmapMode, xmlTextWrite
     switch(eBitmapMode)
     {
         case drawing::BitmapMode_REPEAT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapMode"), "%s", "REPEAT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapMode"), "%s", "REPEAT");
             break;
         case drawing::BitmapMode_STRETCH:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapMode"), "%s", "STRETCH");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapMode"), "%s", "STRETCH");
             break;
         case drawing::BitmapMode_NO_REPEAT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapMode"), "%s", "NO_REPEAT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapMode"), "%s", "NO_REPEAT");
             break;
         default:
             break;
@@ -432,17 +432,17 @@ void dumpFillBitmapModeAsAttribute(drawing::BitmapMode eBitmapMode, xmlTextWrite
 void dumpFillBitmapStretchAsAttribute(bool bBitmapStretch, xmlTextWriterPtr xmlWriter)
 {
     if(bBitmapStretch)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapStretch"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapStretch"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapStretch"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapStretch"), "%s", "false");
 }
 
 void dumpFillBitmapTileAsAttribute(bool bBitmapTile, xmlTextWriterPtr xmlWriter)
 {
     if(bBitmapTile)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapTile"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapTile"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapTile"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fillBitmapTile"), "%s", "false");
 }
 
 
@@ -454,13 +454,13 @@ void dumpLineStyleAsAttribute(drawing::LineStyle eLineStyle, xmlTextWriterPtr xm
     switch(eLineStyle)
     {
         case drawing::LineStyle_NONE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineStyle"), "%s", "NONE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineStyle"), "%s", "NONE");
             break;
         case drawing::LineStyle_SOLID:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineStyle"), "%s", "SOLID");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineStyle"), "%s", "SOLID");
             break;
         case drawing::LineStyle_DASH:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineStyle"), "%s", "DASH");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineStyle"), "%s", "DASH");
             break;
         default:
             break;
@@ -469,51 +469,51 @@ void dumpLineStyleAsAttribute(drawing::LineStyle eLineStyle, xmlTextWriterPtr xm
 
 void dumpLineDashAsElement(const drawing::LineDash& rLineDash, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "LineDash" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "LineDash" ));
     switch (rLineDash.Style)
     {
         case drawing::DashStyle_RECT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "RECT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "RECT");
             break;
         case drawing::DashStyle_ROUND:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "ROUND");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "ROUND");
             break;
         case drawing::DashStyle_RECTRELATIVE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "RECTRELATIVE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "RECTRELATIVE");
             break;
         case drawing::DashStyle_ROUNDRELATIVE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "ROUNDRELATIVE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("style"), "%s", "ROUNDRELATIVE");
             break;
         default:
             break;
     }
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("dots"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rLineDash.Dots));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("dotLen"), "%" SAL_PRIdINT32, rLineDash.DotLen);
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("dashes"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rLineDash.Dashes));
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("dashLen"), "%" SAL_PRIdINT32, rLineDash.DashLen);
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("distance"), "%" SAL_PRIdINT32, rLineDash.Distance);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("dots"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rLineDash.Dots));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("dotLen"), "%" SAL_PRIdINT32, rLineDash.DotLen);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("dashes"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(rLineDash.Dashes));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("dashLen"), "%" SAL_PRIdINT32, rLineDash.DashLen);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("distance"), "%" SAL_PRIdINT32, rLineDash.Distance);
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpLineDashNameAsAttribute(std::u16string_view sLineDashName, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineDashName"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineDashName"), "%s",
         OUStringToOString(sLineDashName, RTL_TEXTENCODING_UTF8).getStr());
 }
 
 void dumpLineColorAsAttribute(sal_Int32 aLineColor, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineColor"), "%06x", static_cast<unsigned int>(aLineColor));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineColor"), "%06x", static_cast<unsigned int>(aLineColor));
 }
 
 void dumpLineTransparenceAsAttribute(sal_Int32 aLineTransparence, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineTransparence"), "%" SAL_PRIdINT32, aLineTransparence);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineTransparence"), "%" SAL_PRIdINT32, aLineTransparence);
 }
 
 void dumpLineWidthAsAttribute(sal_Int32 aLineWidth, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineWidth"), "%" SAL_PRIdINT32, aLineWidth);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineWidth"), "%" SAL_PRIdINT32, aLineWidth);
 }
 
 void dumpLineJointAsAttribute(drawing::LineJoint eLineJoint, xmlTextWriterPtr xmlWriter)
@@ -521,19 +521,19 @@ void dumpLineJointAsAttribute(drawing::LineJoint eLineJoint, xmlTextWriterPtr xm
     switch(eLineJoint)
     {
         case drawing::LineJoint_NONE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineJoint"), "%s", "NONE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineJoint"), "%s", "NONE");
             break;
         case drawing::LineJoint_MIDDLE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineJoint"), "%s", "MIDDLE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineJoint"), "%s", "MIDDLE");
             break;
         case drawing::LineJoint_BEVEL:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineJoint"), "%s", "BEVEL");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineJoint"), "%s", "BEVEL");
             break;
         case drawing::LineJoint_MITER:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineJoint"), "%s", "MITER");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineJoint"), "%s", "MITER");
             break;
         case drawing::LineJoint_ROUND:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineJoint"), "%s", "ROUND");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineJoint"), "%s", "ROUND");
             break;
         default:
             break;
@@ -542,13 +542,13 @@ void dumpLineJointAsAttribute(drawing::LineJoint eLineJoint, xmlTextWriterPtr xm
 
 void dumpLineStartNameAsAttribute(std::u16string_view sLineStartName, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineStartName"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineStartName"), "%s",
     OUStringToOString(sLineStartName, RTL_TEXTENCODING_UTF8).getStr());
 }
 
 void dumpLineEndNameAsAttribute(std::u16string_view sLineEndName, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineEndName"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineEndName"), "%s",
     OUStringToOString(sLineEndName, RTL_TEXTENCODING_UTF8).getStr());
 }
 
@@ -559,42 +559,42 @@ void dumpPolyPolygonBezierCoords(const drawing::PolyPolygonBezierCoords& rPolyPo
 
 void dumpLineStartAsElement(const drawing::PolyPolygonBezierCoords& rLineStart, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "LineStart" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "LineStart" ));
     dumpPolyPolygonBezierCoords(rLineStart, xmlWriter);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpLineEndAsElement(const drawing::PolyPolygonBezierCoords& rLineEnd, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "LineEnd" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "LineEnd" ));
     dumpPolyPolygonBezierCoords(rLineEnd, xmlWriter);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpLineStartCenterAsAttribute(bool bLineStartCenter, xmlTextWriterPtr xmlWriter)
 {
     if(bLineStartCenter)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineStartCenter"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineStartCenter"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineStartCenter"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineStartCenter"), "%s", "false");
 }
 
 void dumpLineStartWidthAsAttribute(sal_Int32 aLineStartWidth, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineStartWidth"), "%" SAL_PRIdINT32, aLineStartWidth);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineStartWidth"), "%" SAL_PRIdINT32, aLineStartWidth);
 }
 
 void dumpLineEndCenterAsAttribute(bool bLineEndCenter, xmlTextWriterPtr xmlWriter)
 {
     if(bLineEndCenter)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineEndCenter"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineEndCenter"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineEndCenter"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("lineEndCenter"), "%s", "false");
 }
 
 void dumpLineEndWidthAsAttribute(sal_Int32 aLineEndWidth, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineEndWidth"), "%" SAL_PRIdINT32, aLineEndWidth);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("lineEndWidth"), "%" SAL_PRIdINT32, aLineEndWidth);
 }
 
 
@@ -606,31 +606,31 @@ void dumpPolygonKindAsAttribute(drawing::PolygonKind ePolygonKind, xmlTextWriter
     switch(ePolygonKind)
     {
         case drawing::PolygonKind_LINE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "LINE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "LINE");
             break;
         case drawing::PolygonKind_POLY:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "POLY");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "POLY");
             break;
         case drawing::PolygonKind_PLIN:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "PLIN");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "PLIN");
             break;
         case drawing::PolygonKind_PATHLINE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "PATHLINE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "PATHLINE");
             break;
         case drawing::PolygonKind_PATHFILL:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "PATHFILL");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "PATHFILL");
             break;
         case drawing::PolygonKind_FREELINE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "FREELINE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "FREELINE");
             break;
         case drawing::PolygonKind_FREEFILL:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "FREEFILL");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "FREEFILL");
             break;
         case drawing::PolygonKind_PATHPOLY:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "PATHPOLY");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "PATHPOLY");
             break;
         case drawing::PolygonKind_PATHPLIN:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "PATHPLIN");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonKind"), "%s", "PATHPLIN");
             break;
         default:
             break;
@@ -652,64 +652,64 @@ void dumpPointSequenceSequence(const drawing::PointSequenceSequence& aPointSeque
         if(pFlags)
             flagsSequence = (*pFlags)[i];
 
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( "pointSequence" ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "pointSequence" ));
 
         for(sal_Int32 j = 0; j < nPoints; ++j)
         {
-            xmlTextWriterStartElement(xmlWriter, BAD_CAST( "point" ));
-            xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("positionX"), "%" SAL_PRIdINT32, pointSequence[j].X);
-            xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("positionY"), "%" SAL_PRIdINT32, pointSequence[j].Y);
+            (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "point" ));
+            (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("positionX"), "%" SAL_PRIdINT32, pointSequence[j].X);
+            (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("positionY"), "%" SAL_PRIdINT32, pointSequence[j].Y);
 
             if(pFlags)
             {
                 switch(flagsSequence[j])
                 {
                     case drawing::PolygonFlags_NORMAL:
-                        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonFlags"), "%s", "NORMAL");
+                        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonFlags"), "%s", "NORMAL");
                         break;
                     case drawing::PolygonFlags_SMOOTH:
-                        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonFlags"), "%s", "SMOOTH");
+                        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonFlags"), "%s", "SMOOTH");
                         break;
                     case drawing::PolygonFlags_CONTROL:
-                        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonFlags"), "%s", "CONTROL");
+                        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonFlags"), "%s", "CONTROL");
                         break;
                     case drawing::PolygonFlags_SYMMETRIC:
-                        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonFlags"), "%s", "SYMMETRIC");
+                        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("polygonFlags"), "%s", "SYMMETRIC");
                         break;
                     default:
                         break;
                 }
             }
 
-            xmlTextWriterEndElement( xmlWriter );
+            (void)xmlTextWriterEndElement( xmlWriter );
         }
-        xmlTextWriterEndElement( xmlWriter );
+        (void)xmlTextWriterEndElement( xmlWriter );
     }
 }
 
 void dumpPolyPolygonAsElement(const drawing::PointSequenceSequence& rPolyPolygon, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "PolyPolygon" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "PolyPolygon" ));
     dumpPointSequenceSequence(rPolyPolygon, nullptr, xmlWriter);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpGeometryAsElement(const drawing::PointSequenceSequence& aGeometry, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Geometry" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Geometry" ));
     dumpPointSequenceSequence(aGeometry, nullptr, xmlWriter);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 // CharacterProperties.idl
 void dumpCharHeightAsAttribute(float fHeight, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fontHeight"), "%f", fHeight );
+    (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("fontHeight"), "%f", fHeight );
 }
 
 void dumpCharColorAsAttribute(sal_Int32 aColor, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fontColor"), "%06x", static_cast<unsigned int>(aColor));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("fontColor"), "%06x", static_cast<unsigned int>(aColor));
 }
 
 
@@ -719,33 +719,33 @@ void dumpCharColorAsAttribute(sal_Int32 aColor, xmlTextWriterPtr xmlWriter)
 void dumpIsNumberingAsAttribute(bool bIsNumbering, xmlTextWriterPtr xmlWriter)
 {
     if(bIsNumbering)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("isNumbering"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("isNumbering"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("isNumbering"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("isNumbering"), "%s", "false");
 }
 
 void dumpTextAutoGrowHeightAsAttribute(bool bTextAutoGrowHeight, xmlTextWriterPtr xmlWriter)
 {
     if(bTextAutoGrowHeight)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAutoGrowHeight"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAutoGrowHeight"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAutoGrowHeight"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAutoGrowHeight"), "%s", "false");
 }
 
 void dumpTextAutoGrowWidthAsAttribute(bool bTextAutoGrowWidth, xmlTextWriterPtr xmlWriter)
 {
     if(bTextAutoGrowWidth)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAutoGrowWidth"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAutoGrowWidth"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAutoGrowWidth"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAutoGrowWidth"), "%s", "false");
 }
 
 void dumpTextContourFrameAsAttribute(bool bTextContourFrame, xmlTextWriterPtr xmlWriter)
 {
     if(bTextContourFrame)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textContourFrame"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textContourFrame"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textContourFrame"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textContourFrame"), "%s", "false");
 }
 
 void dumpTextFitToSizeAsAttribute(drawing::TextFitToSizeType eTextFitToSize, xmlTextWriterPtr xmlWriter)
@@ -753,16 +753,16 @@ void dumpTextFitToSizeAsAttribute(drawing::TextFitToSizeType eTextFitToSize, xml
     switch(eTextFitToSize)
     {
         case drawing::TextFitToSizeType_NONE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textFitToSize"), "%s", "NONE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textFitToSize"), "%s", "NONE");
             break;
         case drawing::TextFitToSizeType_PROPORTIONAL:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textFitToSize"), "%s", "PROPORTIONAL");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textFitToSize"), "%s", "PROPORTIONAL");
             break;
         case drawing::TextFitToSizeType_ALLLINES:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textFitToSize"), "%s", "ALLLINES");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textFitToSize"), "%s", "ALLLINES");
             break;
         case drawing::TextFitToSizeType_AUTOFIT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textFitToSize"), "%s", "AUTOFIT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textFitToSize"), "%s", "AUTOFIT");
             break;
         default:
             break;
@@ -774,16 +774,16 @@ void dumpTextHorizontalAdjustAsAttribute(drawing::TextHorizontalAdjust eTextHori
     switch(eTextHorizontalAdjust)
     {
         case drawing::TextHorizontalAdjust_LEFT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textHorizontalAdjust"), "%s", "LEFT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textHorizontalAdjust"), "%s", "LEFT");
             break;
         case drawing::TextHorizontalAdjust_CENTER:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textHorizontalAdjust"), "%s", "CENTER");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textHorizontalAdjust"), "%s", "CENTER");
             break;
         case drawing::TextHorizontalAdjust_RIGHT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textHorizontalAdjust"), "%s", "RIGHT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textHorizontalAdjust"), "%s", "RIGHT");
             break;
         case drawing::TextHorizontalAdjust_BLOCK:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textHorizontalAdjust"), "%s", "BLOCK");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textHorizontalAdjust"), "%s", "BLOCK");
             break;
         default:
             break;
@@ -795,16 +795,16 @@ void dumpTextVerticalAdjustAsAttribute(drawing::TextVerticalAdjust eTextVertical
     switch(eTextVerticalAdjust)
     {
         case drawing::TextVerticalAdjust_TOP:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textVerticalAdjust"), "%s", "TOP");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textVerticalAdjust"), "%s", "TOP");
             break;
         case drawing::TextVerticalAdjust_CENTER:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textVerticalAdjust"), "%s", "CENTER");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textVerticalAdjust"), "%s", "CENTER");
             break;
         case drawing::TextVerticalAdjust_BOTTOM:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textVerticalAdjust"), "%s", "BOTTOM");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textVerticalAdjust"), "%s", "BOTTOM");
             break;
         case drawing::TextVerticalAdjust_BLOCK:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textVerticalAdjust"), "%s", "BLOCK");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textVerticalAdjust"), "%s", "BLOCK");
             break;
         default:
             break;
@@ -813,57 +813,57 @@ void dumpTextVerticalAdjustAsAttribute(drawing::TextVerticalAdjust eTextVertical
 
 void dumpTextLeftDistanceAsAttribute(sal_Int32 aTextLeftDistance, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textLeftDistance"), "%" SAL_PRIdINT32, aTextLeftDistance);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textLeftDistance"), "%" SAL_PRIdINT32, aTextLeftDistance);
 }
 
 void dumpTextRightDistanceAsAttribute(sal_Int32 aTextRightDistance, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textRightDistance"), "%" SAL_PRIdINT32, aTextRightDistance);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textRightDistance"), "%" SAL_PRIdINT32, aTextRightDistance);
 }
 
 void dumpTextUpperDistanceAsAttribute(sal_Int32 aTextUpperDistance, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textUpperDistance"), "%" SAL_PRIdINT32, aTextUpperDistance);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textUpperDistance"), "%" SAL_PRIdINT32, aTextUpperDistance);
 }
 
 void dumpTextLowerDistanceAsAttribute(sal_Int32 aTextLowerDistance, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textLowerDistance"), "%" SAL_PRIdINT32, aTextLowerDistance);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textLowerDistance"), "%" SAL_PRIdINT32, aTextLowerDistance);
 }
 
 void dumpTextMaximumFrameHeightAsAttribute(sal_Int32 aTextMaximumFrameHeight, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textMaximumFrameHeight"), "%" SAL_PRIdINT32, aTextMaximumFrameHeight);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textMaximumFrameHeight"), "%" SAL_PRIdINT32, aTextMaximumFrameHeight);
 }
 
 void dumpTextMaximumFrameWidthAsAttribute(sal_Int32 aTextMaximumFrameWidth, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textMaximumFrameWidth"), "%" SAL_PRIdINT32, aTextMaximumFrameWidth);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textMaximumFrameWidth"), "%" SAL_PRIdINT32, aTextMaximumFrameWidth);
 }
 
 void dumpTextMinimumFrameHeightAsAttribute(sal_Int32 aTextMinimumFrameHeight, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textMinimumFrameHeight"), "%" SAL_PRIdINT32, aTextMinimumFrameHeight);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textMinimumFrameHeight"), "%" SAL_PRIdINT32, aTextMinimumFrameHeight);
 }
 
 void dumpTextMinimumFrameWidthAsAttribute(sal_Int32 aTextMinimumFrameWidth, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textMinimumFrameWidth"), "%" SAL_PRIdINT32, aTextMinimumFrameWidth);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textMinimumFrameWidth"), "%" SAL_PRIdINT32, aTextMinimumFrameWidth);
 }
 
 void dumpTextAnimationAmountAsAttribute(sal_Int32 aTextAnimationAmount, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textAnimationAmount"), "%" SAL_PRIdINT32, aTextAnimationAmount);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textAnimationAmount"), "%" SAL_PRIdINT32, aTextAnimationAmount);
 }
 
 void dumpTextAnimationCountAsAttribute(sal_Int32 aTextAnimationCount, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textAnimationCount"), "%" SAL_PRIdINT32, aTextAnimationCount);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textAnimationCount"), "%" SAL_PRIdINT32, aTextAnimationCount);
 }
 
 void dumpTextAnimationDelayAsAttribute(sal_Int32 aTextAnimationDelay, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textAnimationDelay"), "%" SAL_PRIdINT32, aTextAnimationDelay);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("textAnimationDelay"), "%" SAL_PRIdINT32, aTextAnimationDelay);
 }
 
 void dumpTextAnimationDirectionAsAttribute(drawing::TextAnimationDirection eTextAnimationDirection, xmlTextWriterPtr xmlWriter)
@@ -871,16 +871,16 @@ void dumpTextAnimationDirectionAsAttribute(drawing::TextAnimationDirection eText
     switch(eTextAnimationDirection)
     {
         case drawing::TextAnimationDirection_LEFT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationDirection"), "%s", "LEFT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationDirection"), "%s", "LEFT");
             break;
         case drawing::TextAnimationDirection_RIGHT:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationDirection"), "%s", "RIGHT");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationDirection"), "%s", "RIGHT");
             break;
         case drawing::TextAnimationDirection_UP:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationDirection"), "%s", "UP");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationDirection"), "%s", "UP");
             break;
         case drawing::TextAnimationDirection_DOWN:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationDirection"), "%s", "DOWN");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationDirection"), "%s", "DOWN");
             break;
         default:
             break;
@@ -892,19 +892,19 @@ void dumpTextAnimationKindAsAttribute(drawing::TextAnimationKind eTextAnimationK
     switch(eTextAnimationKind)
     {
         case drawing::TextAnimationKind_NONE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationKind"), "%s", "NONE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationKind"), "%s", "NONE");
             break;
         case drawing::TextAnimationKind_BLINK:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationKind"), "%s", "BLINK");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationKind"), "%s", "BLINK");
             break;
         case drawing::TextAnimationKind_SCROLL:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationKind"), "%s", "SCROLL");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationKind"), "%s", "SCROLL");
             break;
         case drawing::TextAnimationKind_ALTERNATE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationKind"), "%s", "ALTERNATE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationKind"), "%s", "ALTERNATE");
             break;
         case drawing::TextAnimationKind_SLIDE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationKind"), "%s", "SLIDE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationKind"), "%s", "SLIDE");
             break;
         default:
             break;
@@ -914,17 +914,17 @@ void dumpTextAnimationKindAsAttribute(drawing::TextAnimationKind eTextAnimationK
 void dumpTextAnimationStartInsideAsAttribute(bool bTextAnimationStartInside, xmlTextWriterPtr xmlWriter)
 {
     if(bTextAnimationStartInside)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationStartInside"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationStartInside"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationStartInside"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationStartInside"), "%s", "false");
 }
 
 void dumpTextAnimationStopInsideAsAttribute(bool bTextAnimationStopInside, xmlTextWriterPtr xmlWriter)
 {
     if(bTextAnimationStopInside)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationStopInside"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationStopInside"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationStopInside"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textAnimationStopInside"), "%s", "false");
 }
 
 void dumpTextWritingModeAsAttribute(text::WritingMode eTextWritingMode, xmlTextWriterPtr xmlWriter)
@@ -932,13 +932,13 @@ void dumpTextWritingModeAsAttribute(text::WritingMode eTextWritingMode, xmlTextW
     switch(eTextWritingMode)
     {
         case text::WritingMode_LR_TB:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textWritingMode"), "%s", "LR_TB");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textWritingMode"), "%s", "LR_TB");
             break;
         case text::WritingMode_RL_TB:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textWritingMode"), "%s", "RL_TB");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textWritingMode"), "%s", "RL_TB");
             break;
         case text::WritingMode_TB_RL:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textWritingMode"), "%s", "TB_RL");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("textWritingMode"), "%s", "TB_RL");
             break;
         default:
             break;
@@ -952,29 +952,29 @@ void dumpTextWritingModeAsAttribute(text::WritingMode eTextWritingMode, xmlTextW
 void dumpShadowAsAttribute(bool bShadow, xmlTextWriterPtr xmlWriter)
 {
     if(bShadow)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadow"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadow"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadow"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("shadow"), "%s", "false");
 }
 
 void dumpShadowColorAsAttribute(sal_Int32 aShadowColor, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("shadowColor"), "%06x", static_cast<unsigned int>(aShadowColor));
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("shadowColor"), "%06x", static_cast<unsigned int>(aShadowColor));
 }
 
 void dumpShadowTransparenceAsAttribute(sal_Int32 aShadowTransparence, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("shadowTransparence"), "%" SAL_PRIdINT32, aShadowTransparence);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("shadowTransparence"), "%" SAL_PRIdINT32, aShadowTransparence);
 }
 
 void dumpShadowXDistanceAsAttribute(sal_Int32 aShadowXDistance, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("shadowXDistance"), "%" SAL_PRIdINT32, aShadowXDistance);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("shadowXDistance"), "%" SAL_PRIdINT32, aShadowXDistance);
 }
 
 void dumpShadowYDistanceAsAttribute(sal_Int32 aShadowYDistance, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("shadowYDistance"), "%" SAL_PRIdINT32, aShadowYDistance);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("shadowYDistance"), "%" SAL_PRIdINT32, aShadowYDistance);
 }
 
 
@@ -983,49 +983,49 @@ void dumpShadowYDistanceAsAttribute(sal_Int32 aShadowYDistance, xmlTextWriterPtr
 
 void dumpZOrderAsAttribute(sal_Int32 aZOrder, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("zOrder"), "%" SAL_PRIdINT32, aZOrder);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("zOrder"), "%" SAL_PRIdINT32, aZOrder);
 }
 
 void dumpLayerIDAsAttribute(sal_Int32 aLayerID, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("layerID"), "%" SAL_PRIdINT32, aLayerID);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("layerID"), "%" SAL_PRIdINT32, aLayerID);
 }
 
 void dumpLayerNameAsAttribute(std::u16string_view sLayerName, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("layerName"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("layerName"), "%s",
         OUStringToOString(sLayerName, RTL_TEXTENCODING_UTF8).getStr());
 }
 
 void dumpVisibleAsAttribute(bool bVisible, xmlTextWriterPtr xmlWriter)
 {
     if(bVisible)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("visible"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("visible"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("visible"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("visible"), "%s", "false");
 }
 
 void dumpPrintableAsAttribute(bool bPrintable, xmlTextWriterPtr xmlWriter)
 {
     if(bPrintable)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("printable"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("printable"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("printable"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("printable"), "%s", "false");
 }
 
 void dumpMoveProtectAsAttribute(bool bMoveProtect, xmlTextWriterPtr xmlWriter)
 {
     if(bMoveProtect)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("moveProtect"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("moveProtect"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("moveProtect"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("moveProtect"), "%s", "false");
 }
 
 void dumpNameAsAttribute(std::u16string_view sName, xmlTextWriterPtr xmlWriter)
 {
     if(!sName.empty() && !m_bNameDumped)
     {
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("name"), "%s", OUStringToOString(sName, RTL_TEXTENCODING_UTF8).getStr());
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("name"), "%s", OUStringToOString(sName, RTL_TEXTENCODING_UTF8).getStr());
         m_bNameDumped = true;
     }
 }
@@ -1033,55 +1033,55 @@ void dumpNameAsAttribute(std::u16string_view sName, xmlTextWriterPtr xmlWriter)
 void dumpSizeProtectAsAttribute(bool bSizeProtect, xmlTextWriterPtr xmlWriter)
 {
     if(bSizeProtect)
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("sizeProtect"), "%s", "true");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("sizeProtect"), "%s", "true");
     else
-        xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("sizeProtect"), "%s", "false");
+        (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("sizeProtect"), "%s", "false");
 }
 
 void dumpHomogenMatrixLine3(const drawing::HomogenMatrixLine3& rHomogenMatrixLine3, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("column1"), "%f", rHomogenMatrixLine3.Column1);
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("column2"), "%f", rHomogenMatrixLine3.Column2);
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("column3"), "%f", rHomogenMatrixLine3.Column3);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("column1"), "%f", rHomogenMatrixLine3.Column1);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("column2"), "%f", rHomogenMatrixLine3.Column2);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("column3"), "%f", rHomogenMatrixLine3.Column3);
 }
 
 void dumpTransformationAsElement(const drawing::HomogenMatrix3& rTransformation, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Transformation" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Transformation" ));
     {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Line1" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Line1" ));
     dumpHomogenMatrixLine3(rTransformation.Line1, xmlWriter);
-    xmlTextWriterEndElement( xmlWriter );
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Line2" ));
+    (void)xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Line2" ));
     dumpHomogenMatrixLine3(rTransformation.Line2, xmlWriter);
-    xmlTextWriterEndElement( xmlWriter );
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Line3" ));
+    (void)xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "Line3" ));
     dumpHomogenMatrixLine3(rTransformation.Line3, xmlWriter);
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpNavigationOrderAsAttribute(sal_Int32 aNavigationOrder, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("navigationOrder"), "%" SAL_PRIdINT32, aNavigationOrder);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("navigationOrder"), "%" SAL_PRIdINT32, aNavigationOrder);
 }
 
 void dumpHyperlinkAsAttribute(std::u16string_view sHyperlink, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("hyperlink"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("hyperlink"), "%s",
         OUStringToOString(sHyperlink, RTL_TEXTENCODING_UTF8).getStr());
 }
 
 void dumpInteropGrabBagAsElement(const uno::Sequence< beans::PropertyValue>& aInteropGrabBag, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "InteropGrabBag" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "InteropGrabBag" ));
 
     sal_Int32 nLength = aInteropGrabBag.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
         dumpPropertyValueAsElement(aInteropGrabBag[i], xmlWriter);
 
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 
@@ -1090,19 +1090,19 @@ void dumpInteropGrabBagAsElement(const uno::Sequence< beans::PropertyValue>& aIn
 
 void dumpPositionAsAttribute(const awt::Point& rPoint, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("positionX"), "%" SAL_PRIdINT32, rPoint.X);
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("positionY"), "%" SAL_PRIdINT32, rPoint.Y);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("positionX"), "%" SAL_PRIdINT32, rPoint.X);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("positionY"), "%" SAL_PRIdINT32, rPoint.Y);
 }
 
 void dumpSizeAsAttribute(const awt::Size& rSize, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("sizeX"), "%" SAL_PRIdINT32, rSize.Width);
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("sizeY"), "%" SAL_PRIdINT32, rSize.Height);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("sizeX"), "%" SAL_PRIdINT32, rSize.Width);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("sizeY"), "%" SAL_PRIdINT32, rSize.Height);
 }
 
 void dumpShapeDescriptorAsAttribute( const uno::Reference< drawing::XShapeDescriptor >& xDescr, xmlTextWriterPtr xmlWriter )
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("type"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("type"), "%s",
         OUStringToOString(xDescr->getShapeType(), RTL_TEXTENCODING_UTF8).getStr());
 }
 
@@ -1112,22 +1112,22 @@ void dumpShapeDescriptorAsAttribute( const uno::Reference< drawing::XShapeDescri
 
 void dumpCustomShapeEngineAsAttribute(std::u16string_view sCustomShapeEngine, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("customShapeEngine"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("customShapeEngine"), "%s",
         OUStringToOString(sCustomShapeEngine, RTL_TEXTENCODING_UTF8).getStr());
 }
 
 void dumpCustomShapeDataAsAttribute(
     std::u16string_view sCustomShapeData, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("customShapeData"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("customShapeData"), "%s",
         OUStringToOString(sCustomShapeData, RTL_TEXTENCODING_UTF8).getStr());
 }
 
 void dumpPropertyValueAsElement(const beans::PropertyValue& rPropertyValue, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "PropertyValue" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "PropertyValue" ));
 
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("name"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("name"), "%s",
             OUStringToOString(rPropertyValue.Name, RTL_TEXTENCODING_UTF8).getStr());
 
     uno::Any aAny = rPropertyValue.Value;
@@ -1142,20 +1142,20 @@ void dumpPropertyValueAsElement(const beans::PropertyValue& rPropertyValue, xmlT
     uno::Sequence< beans::PropertyValue > aPropSeq;
     if(aAny >>= sValue)
     {
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s",
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s",
                 OUStringToOString(sValue, RTL_TEXTENCODING_UTF8).getStr());
     }
     else if(aAny >>= nValue)
     {
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%" SAL_PRIdINT32, nValue);
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%" SAL_PRIdINT32, nValue);
     }
     else if(aAny >>= fValue)
     {
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%f", fValue);
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%f", fValue);
     }
     else if(aAny >>= bValue)
     {
-        xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s", (bValue? "true": "false"));
+        (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("value"), "%s", (bValue? "true": "false"));
     }
     else if(rPropertyValue.Name == "ViewBox" && (aAny >>= aRectangleValue))
     {
@@ -1179,13 +1179,13 @@ void dumpPropertyValueAsElement(const beans::PropertyValue& rPropertyValue, xmlT
     }
     else if(aAny >>= aPropSeq)
     {
-        xmlTextWriterStartElement(xmlWriter, BAD_CAST( OUStringToOString(rPropertyValue.Name, RTL_TEXTENCODING_UTF8).getStr() ));
+        (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( OUStringToOString(rPropertyValue.Name, RTL_TEXTENCODING_UTF8).getStr() ));
 
         sal_Int32 i = 0, nCount = aPropSeq.getLength();
         for ( ; i < nCount; i++ )
             dumpPropertyValueAsElement(aPropSeq[ i ], xmlWriter);
 
-        xmlTextWriterEndElement(xmlWriter);
+        (void)xmlTextWriterEndElement(xmlWriter);
     }
 
     // TODO: Add here dumping of XDocument for future OOX Smart-Art
@@ -1193,39 +1193,39 @@ void dumpPropertyValueAsElement(const beans::PropertyValue& rPropertyValue, xmlT
 
     // TODO more, if necessary
 
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("handle"), "%" SAL_PRIdINT32, rPropertyValue.Handle);
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("handle"), "%" SAL_PRIdINT32, rPropertyValue.Handle);
 
     switch(rPropertyValue.State)
     {
         case beans::PropertyState_DIRECT_VALUE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DIRECT_VALUE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DIRECT_VALUE");
             break;
         case beans::PropertyState_DEFAULT_VALUE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DEFAULT_VALUE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "DEFAULT_VALUE");
             break;
         case beans::PropertyState_AMBIGUOUS_VALUE:
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "AMBIGUOUS_VALUE");
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("propertyState"), "%s", "AMBIGUOUS_VALUE");
             break;
         default:
             break;
     }
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpCustomShapeGeometryAsElement(const uno::Sequence< beans::PropertyValue>& aCustomShapeGeometry, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterStartElement(xmlWriter, BAD_CAST( "CustomShapeGeometry" ));
+    (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "CustomShapeGeometry" ));
 
     sal_Int32 nLength = aCustomShapeGeometry.getLength();
     for (sal_Int32 i = 0; i < nLength; ++i)
         dumpPropertyValueAsElement(aCustomShapeGeometry[i], xmlWriter);
 
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpCustomShapeReplacementURLAsAttribute(std::u16string_view sCustomShapeReplacementURL, xmlTextWriterPtr xmlWriter)
 {
-    xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("customShapeReplacementURL"), "%s",
+    (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST("customShapeReplacementURL"), "%s",
         OUStringToOString(sCustomShapeReplacementURL, RTL_TEXTENCODING_UTF8).getStr());
 }
 
@@ -1816,7 +1816,7 @@ void dumpCustomShapeService(const uno::Reference< beans::XPropertySet >& xPropSe
 
 void dumpXShape(const uno::Reference< drawing::XShape >& xShape, xmlTextWriterPtr xmlWriter, bool bDumpInteropProperties)
 {
-    xmlTextWriterStartElement( xmlWriter, BAD_CAST( "XShape" ) );
+    (void)xmlTextWriterStartElement( xmlWriter, BAD_CAST( "XShape" ) );
     uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY_THROW);
     OUString aName;
     m_bNameDumped = false;
@@ -1836,7 +1836,7 @@ void dumpXShape(const uno::Reference< drawing::XShape >& xShape, xmlTextWriterPt
         uno::Any aAny = xPropSet->getPropertyValue("Name");
         if ((aAny >>= aName) && !aName.isEmpty())
         {
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("name"), "%s", OUStringToOString(aName, RTL_TEXTENCODING_UTF8).getStr());
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("name"), "%s", OUStringToOString(aName, RTL_TEXTENCODING_UTF8).getStr());
             m_bNameDumped = true;
         }
     }
@@ -1848,7 +1848,7 @@ void dumpXShape(const uno::Reference< drawing::XShape >& xShape, xmlTextWriterPt
         uno::Reference< text::XText > xText(xShape, uno::UNO_QUERY_THROW);
         OUString aText = xText->getString();
         if(!aText.isEmpty())
-            xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("text"), "%s", OUStringToOString(aText, RTL_TEXTENCODING_UTF8).getStr());
+            (void)xmlTextWriterWriteFormatAttribute( xmlWriter, BAD_CAST("text"), "%s", OUStringToOString(aText, RTL_TEXTENCODING_UTF8).getStr());
     }
     if(xServiceInfo->supportsService("com.sun.star.drawing.TextProperties"))
         dumpTextPropertiesService(xPropSet, xmlWriter);
@@ -1917,18 +1917,18 @@ void dumpXShape(const uno::Reference< drawing::XShape >& xShape, xmlTextWriterPt
         sal_Int32 nServices = aServiceNames.getLength();
         for (sal_Int32 i = 0; i < nServices; ++i)
         {
-            xmlTextWriterStartElement(xmlWriter, BAD_CAST( "ServiceName" ));
-            xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST( "name" ), "%s", OUStringToOString(aServiceNames[i], RTL_TEXTENCODING_UTF8).getStr());
-            xmlTextWriterEndElement( xmlWriter );
+            (void)xmlTextWriterStartElement(xmlWriter, BAD_CAST( "ServiceName" ));
+            (void)xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST( "name" ), "%s", OUStringToOString(aServiceNames[i], RTL_TEXTENCODING_UTF8).getStr());
+            (void)xmlTextWriterEndElement( xmlWriter );
         }
     #endif
 
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 
 void dumpXShapes( const uno::Reference< drawing::XShapes >& xShapes, xmlTextWriterPtr xmlWriter, bool bDumpInteropProperties )
 {
-    xmlTextWriterStartElement( xmlWriter, BAD_CAST( "XShapes" ) );
+    (void)xmlTextWriterStartElement( xmlWriter, BAD_CAST( "XShapes" ) );
     uno::Reference< container::XIndexAccess > xIA( xShapes, uno::UNO_QUERY_THROW);
     sal_Int32 nLength = xIA->getCount();
     for (sal_Int32 i = 0; i < nLength; ++i)
@@ -1937,7 +1937,7 @@ void dumpXShapes( const uno::Reference< drawing::XShapes >& xShapes, xmlTextWrit
         dumpXShape( xShape, xmlWriter, bDumpInteropProperties );
     }
 
-    xmlTextWriterEndElement( xmlWriter );
+    (void)xmlTextWriterEndElement( xmlWriter );
 }
 } //end of namespace
 
@@ -1948,7 +1948,7 @@ OUString XShapeDumper::dump(const uno::Reference<drawing::XShapes>& xPageShapes,
     xmlTextWriterPtr xmlWriter = xmlNewTextWriter( xmlOutBuffer );
     xmlTextWriterSetIndent( xmlWriter, 1 );
 
-    xmlTextWriterStartDocument( xmlWriter, nullptr, nullptr, nullptr );
+    (void)xmlTextWriterStartDocument( xmlWriter, nullptr, nullptr, nullptr );
 
     try
     {
@@ -1959,7 +1959,7 @@ OUString XShapeDumper::dump(const uno::Reference<drawing::XShapes>& xPageShapes,
         std::cout << "Exception caught in XShapeDumper: " << e.Message << std::endl;
     }
 
-    xmlTextWriterEndDocument( xmlWriter );
+    (void)xmlTextWriterEndDocument( xmlWriter );
     xmlFreeTextWriter( xmlWriter );
 
     return OUString::fromUtf8(aString.makeStringAndClear());
@@ -1972,7 +1972,7 @@ OUString XShapeDumper::dump(const uno::Reference<drawing::XShape>& xPageShapes,
     xmlTextWriterPtr xmlWriter = xmlNewTextWriter( xmlOutBuffer );
     xmlTextWriterSetIndent( xmlWriter, 1 );
 
-    xmlTextWriterStartDocument( xmlWriter, nullptr, nullptr, nullptr );
+    (void)xmlTextWriterStartDocument( xmlWriter, nullptr, nullptr, nullptr );
 
     try
     {
@@ -1983,7 +1983,7 @@ OUString XShapeDumper::dump(const uno::Reference<drawing::XShape>& xPageShapes,
         std::cout << "Exception caught in XShapeDumper: " << e.Message << std::endl;
     }
 
-    xmlTextWriterEndDocument( xmlWriter );
+    (void)xmlTextWriterEndDocument( xmlWriter );
     xmlFreeTextWriter( xmlWriter );
 
     return OUString::fromUtf8(aString.makeStringAndClear());
diff --git a/editeng/source/editeng/editattr.cxx b/editeng/source/editeng/editattr.cxx
index e48445c27c30..dc5b50395441 100644
--- a/editeng/source/editeng/editattr.cxx
+++ b/editeng/source/editeng/editattr.cxx
@@ -65,13 +65,13 @@ void EditCharAttrib::SetFont( SvxFont&, OutputDevice* )
 
 void EditCharAttrib::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("EditCharAttrib"));
-    xmlTextWriterWriteFormatAttribute(
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("EditCharAttrib"));
+    (void)xmlTextWriterWriteFormatAttribute(
     pWriter, BAD_CAST("nStart"), "%" SAL_PRIdINT32, nStart);
-    xmlTextWriterWriteFormatAttribute(
+    (void)xmlTextWriterWriteFormatAttribute(
     pWriter, BAD_CAST("nEnd"), "%" SAL_PRIdINT32, nEnd);
     pItem->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
diff --git a/editeng/source/editeng/editdoc.cxx b/editeng/source/editeng/editdoc.cxx
index 19f4362a8ff8..a5e28d0c6b34 100644
--- a/editeng/source/editeng/editdoc.cxx
+++ b/editeng/source/editeng/editdoc.cxx
@@ -1789,11 +1789,11 @@ void ContentNode::DestroyWrongList()
 
 void ContentNode::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("ContentNode"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("maString"), BAD_CAST(maString.toUtf8().getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("ContentNode"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("maString"), BAD_CAST(maString.toUtf8().getStr()));
     aContentAttribs.dumpAsXml(pWriter);
     aCharAttribList.dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -1864,10 +1864,10 @@ bool ContentAttribs::HasItem( sal_uInt16 nWhich ) const
 
 void ContentAttribs::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("ContentAttribs"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("style"), "%s", pStyle->GetName().toUtf8().getStr());
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("ContentAttribs"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("style"), "%s", pStyle->GetName().toUtf8().getStr());
     aAttribSet.dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -2696,20 +2696,20 @@ void EditDoc::dumpAsXml(xmlTextWriterPtr pWriter) const
         pWriter = xmlNewTextWriterFilename("editdoc.xml", 0);
         xmlTextWriterSetIndent(pWriter,1);
         xmlTextWriterSetIndentString(pWriter, BAD_CAST("  "));
-        xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
+        (void)xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
         bOwns = true;
     }
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("EditDoc"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("EditDoc"));
     for (auto const & i : maContents)
     {
         i->dumpAsXml(pWriter);
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
     if (bOwns)
     {
-       xmlTextWriterEndDocument(pWriter);
+       (void)xmlTextWriterEndDocument(pWriter);
        xmlFreeTextWriter(pWriter);
     }
 }
@@ -3011,11 +3011,11 @@ void CharAttribList::DbgCheckAttribs(CharAttribList const& rAttribs)
 
 void CharAttribList::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("CharAttribList"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("CharAttribList"));
     for (auto const & i : aAttribs) {
         i->dumpAsXml(pWriter);
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 EditEngineItemPool::EditEngineItemPool()
diff --git a/editeng/source/editeng/editobj.cxx b/editeng/source/editeng/editobj.cxx
index fb872ca870eb..05abf41a7b67 100644
--- a/editeng/source/editeng/editobj.cxx
+++ b/editeng/source/editeng/editobj.cxx
@@ -151,21 +151,21 @@ void ContentInfo::SetText( const OUString& rStr )
 
 void ContentInfo::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("ContentInfo"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("style"), BAD_CAST(aStyle.toUtf8().getStr()));
-    xmlTextWriterStartElement(pWriter, BAD_CAST("text"));
-    xmlTextWriterWriteString(pWriter, BAD_CAST(GetText().toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("ContentInfo"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("style"), BAD_CAST(aStyle.toUtf8().getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("text"));
+    (void)xmlTextWriterWriteString(pWriter, BAD_CAST(GetText().toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
     aParaAttribs.dumpAsXml(pWriter);
     for (size_t i=0; i<maCharAttribs.size(); ++i)
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("attribs"));
-        xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("start"), "%" SAL_PRIdINT32, maCharAttribs[i]->GetStart());
-        xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("end"), "%" SAL_PRIdINT32, maCharAttribs[i]->GetEnd());
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("attribs"));
+        (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("start"), "%" SAL_PRIdINT32, maCharAttribs[i]->GetStart());
+        (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("end"), "%" SAL_PRIdINT32, maCharAttribs[i]->GetEnd());
         maCharAttribs[i]->GetItem()->dumpAsXml(pWriter);
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 const WrongList* ContentInfo::GetWrongList() const
@@ -422,21 +422,21 @@ void EditTextObject::dumpAsXml(xmlTextWriterPtr pWriter) const
         pWriter = xmlNewTextWriterFilename("editTextObject.xml", 0);
         xmlTextWriterSetIndent(pWriter,1);
         xmlTextWriterSetIndentString(pWriter, BAD_CAST("  "));
-        xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
+        (void)xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
         bOwns = true;
     }
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("EditTextObject"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("EditTextObject"));
     sal_Int32 nCount = GetParagraphCount();
     for (sal_Int32 i = 0; i < nCount; ++i)
     {
         mpImpl->aContents[i]->dumpAsXml(pWriter);
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
     if (bOwns)
     {
-       xmlTextWriterEndDocument(pWriter);
+       (void)xmlTextWriterEndDocument(pWriter);
        xmlFreeTextWriter(pWriter);
     }
 }
diff --git a/editeng/source/items/frmitems.cxx b/editeng/source/items/frmitems.cxx
index d010089b3052..13f70dabf6a5 100644
--- a/editeng/source/items/frmitems.cxx
+++ b/editeng/source/items/frmitems.cxx
@@ -603,23 +603,23 @@ bool SvxLRSpaceItem::HasMetrics() const
 
 void SvxLRSpaceItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxLRSpaceItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nFirstLineOffset"), BAD_CAST(OString::number(nFirstLineOffset).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nTxtLeft"), BAD_CAST(OString::number(nTxtLeft).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLeftMargin"), BAD_CAST(OString::number(nLeftMargin).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nRightMargin"), BAD_CAST(OString::number(nRightMargin).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nGutterMargin"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxLRSpaceItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nFirstLineOffset"), BAD_CAST(OString::number(nFirstLineOffset).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nTxtLeft"), BAD_CAST(OString::number(nTxtLeft).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLeftMargin"), BAD_CAST(OString::number(nLeftMargin).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nRightMargin"), BAD_CAST(OString::number(nRightMargin).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nGutterMargin"),
                                 BAD_CAST(OString::number(m_nGutterMargin).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nRightGutterMargin"),
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nRightGutterMargin"),
                                 BAD_CAST(OString::number(m_nRightGutterMargin).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropFirstLineOffset"), BAD_CAST(OString::number(nPropFirstLineOffset).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropLeftMargin"), BAD_CAST(OString::number(nPropLeftMargin).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropRightMargin"), BAD_CAST(OString::number(nPropRightMargin).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bAutoFirst"), BAD_CAST(OString::number(int(bAutoFirst)).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bExplicitZeroMarginValRight"), BAD_CAST(OString::number(int(bExplicitZeroMarginValRight)).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bExplicitZeroMarginValLeft"), BAD_CAST(OString::number(int(bExplicitZeroMarginValLeft)).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropFirstLineOffset"), BAD_CAST(OString::number(nPropFirstLineOffset).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropLeftMargin"), BAD_CAST(OString::number(nPropLeftMargin).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropRightMargin"), BAD_CAST(OString::number(nPropRightMargin).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bAutoFirst"), BAD_CAST(OString::number(int(bAutoFirst)).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bExplicitZeroMarginValRight"), BAD_CAST(OString::number(int(bExplicitZeroMarginValRight)).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bExplicitZeroMarginValLeft"), BAD_CAST(OString::number(int(bExplicitZeroMarginValLeft)).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -857,14 +857,14 @@ bool SvxULSpaceItem::HasMetrics() const
 
 void SvxULSpaceItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxULSpaceItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nUpper"), BAD_CAST(OString::number(nUpper).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLower"), BAD_CAST(OString::number(nLower).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bContext"), BAD_CAST(OString::boolean(bContext).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropUpper"), BAD_CAST(OString::number(nPropUpper).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropLower"), BAD_CAST(OString::number(nPropLower).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxULSpaceItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nUpper"), BAD_CAST(OString::number(nUpper).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLower"), BAD_CAST(OString::number(nLower).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bContext"), BAD_CAST(OString::boolean(bContext).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropUpper"), BAD_CAST(OString::number(nPropUpper).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropLower"), BAD_CAST(OString::number(nPropLower).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 boost::property_tree::ptree SvxULSpaceItem::dumpAsJSON() const
@@ -1013,12 +1013,12 @@ bool SvxProtectItem::GetPresentation
 
 void SvxProtectItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxProtectItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("content"), BAD_CAST(OString::boolean(bCntnt).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(OString::boolean(bSize).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("position"), BAD_CAST(OString::boolean(bPos).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxProtectItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("content"), BAD_CAST(OString::boolean(bCntnt).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(OString::boolean(bSize).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("position"), BAD_CAST(OString::boolean(bPos).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -1270,13 +1270,13 @@ void SvxShadowItem::SetEnumValue( sal_uInt16 nVal )
 
 void SvxShadowItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxShadowItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aShadowColor"), BAD_CAST(aShadowColor.AsRGBHexString().toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidth"), BAD_CAST(OString::number(nWidth).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eLocation"), BAD_CAST(OString::number(static_cast<int>(eLocation)).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(EditResId(RID_SVXITEMS_SHADOW[static_cast<int>(eLocation)]).toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxShadowItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aShadowColor"), BAD_CAST(aShadowColor.AsRGBHexString().toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidth"), BAD_CAST(OString::number(nWidth).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eLocation"), BAD_CAST(OString::number(static_cast<int>(eLocation)).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(EditResId(RID_SVXITEMS_SHADOW[static_cast<int>(eLocation)]).toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // class SvxBoxItem ------------------------------------------------------
@@ -2664,11 +2664,11 @@ bool SvxFormatKeepItem::GetPresentation
 
 void SvxFormatKeepItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFormatKeepItem"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFormatKeepItem"));
 
     SfxBoolItem::dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SvxLineItem::SvxLineItem( const sal_uInt16 nId ) :
@@ -3337,15 +3337,15 @@ void SvxBrushItem::ApplyGraphicTransparency_Impl()
 
 void SvxBrushItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxBrushItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("color"), BAD_CAST(aColor.AsRGBHexString().toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("shadingValue"), BAD_CAST(OString::number(nShadingValue).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("link"), BAD_CAST(maStrLink.toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("filter"), BAD_CAST(maStrFilter.toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("graphicPos"), BAD_CAST(OString::number(eGraphicPos).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("loadAgain"), BAD_CAST(OString::boolean(bLoadAgain).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxBrushItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("color"), BAD_CAST(aColor.AsRGBHexString().toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("shadingValue"), BAD_CAST(OString::number(nShadingValue).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("link"), BAD_CAST(maStrLink.toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("filter"), BAD_CAST(maStrFilter.toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("graphicPos"), BAD_CAST(OString::number(eGraphicPos).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("loadAgain"), BAD_CAST(OString::boolean(bLoadAgain).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -3469,13 +3469,13 @@ bool SvxFrameDirectionItem::QueryValue( css::uno::Any& rVal,
 
 void SvxFrameDirectionItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFrameDirectionItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nWhich"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFrameDirectionItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nWhich"),
                                 BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(
+    (void)xmlTextWriterWriteAttribute(
         pWriter, BAD_CAST("m_nValue"),
         BAD_CAST(OString::number(static_cast<sal_Int16>(GetValue())).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/numitem.cxx b/editeng/source/items/numitem.cxx
index cd22755e2a38..5873cfb05781 100644
--- a/editeng/source/items/numitem.cxx
+++ b/editeng/source/items/numitem.cxx
@@ -156,9 +156,9 @@ OUString SvxNumberType::GetNumStr( sal_Int32 nNo, const css::lang::Locale& rLoca
 
 void SvxNumberType::dumpAsXml( xmlTextWriterPtr pWriter ) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxNumberType"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("NumType"), BAD_CAST(OString::number(nNumType).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxNumberType"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("NumType"), BAD_CAST(OString::number(nNumType).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SvxNumberFormat::SvxNumberFormat( SvxNumType eType )
@@ -703,22 +703,22 @@ void SvxNumRule::Store( SvStream &rStream )
 
 void SvxNumRule::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxNumRule"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("levelCount"), BAD_CAST(OString::number(nLevelCount).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("continuousNumbering"), BAD_CAST(OString::boolean(bContinuousNumbering).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("numberingType"), BAD_CAST(OString::number(static_cast<int>(eNumberingType)).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("featureFlags"), BAD_CAST(OString::number(static_cast<int>(nFeatureFlags)).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxNumRule"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("levelCount"), BAD_CAST(OString::number(nLevelCount).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("continuousNumbering"), BAD_CAST(OString::boolean(bContinuousNumbering).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("numberingType"), BAD_CAST(OString::number(static_cast<int>(eNumberingType)).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("featureFlags"), BAD_CAST(OString::number(static_cast<int>(nFeatureFlags)).getStr()));
     for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
     {
         if(aFmts[i])
         {
-            xmlTextWriterStartElement(pWriter, BAD_CAST("aFmts"));
-            xmlTextWriterWriteAttribute(pWriter, BAD_CAST("i"), BAD_CAST(OString::number(i).getStr()));
-            xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", aFmts[i].get());
-            xmlTextWriterEndElement(pWriter);
+            (void)xmlTextWriterStartElement(pWriter, BAD_CAST("aFmts"));
+            (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("i"), BAD_CAST(OString::number(i).getStr()));
+            (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", aFmts[i].get());
+            (void)xmlTextWriterEndElement(pWriter);
         }
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -984,10 +984,10 @@ bool SvxNumBulletItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberI
 
 void SvxNumBulletItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxNumBulletItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxNumBulletItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
     pNumRule->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 std::unique_ptr<SvxNumRule> SvxConvertNumRule( const SvxNumRule* pRule, sal_uInt16 nLevels, SvxNumRuleType eType )
diff --git a/editeng/source/items/paraitem.cxx b/editeng/source/items/paraitem.cxx
index 1b1eb2acba06..9bc05843bd22 100644
--- a/editeng/source/items/paraitem.cxx
+++ b/editeng/source/items/paraitem.cxx
@@ -717,12 +717,12 @@ void SvxTabStop::fillDecimal() const
 
 void SvxTabStop::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxTabStop"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nTabPos"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxTabStop"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nTabPos"),
                                 BAD_CAST(OString::number(nTabPos).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eAdjustment"),
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eAdjustment"),
                                 BAD_CAST(OString::number(static_cast<int>(eAdjustment)).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // class SvxTabStopItem --------------------------------------------------
@@ -984,10 +984,10 @@ void SvxTabStopItem::Insert( const SvxTabStopItem* pTabs )
 
 void SvxTabStopItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxTabStopItem"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxTabStopItem"));
     for (const auto& rTabStop : maTabStops)
         rTabStop.dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // class SvxFormatSplitItem -------------------------------------------------
diff --git a/editeng/source/items/textitem.cxx b/editeng/source/items/textitem.cxx
index e63b9c786e1d..776d1210450c 100644
--- a/editeng/source/items/textitem.cxx
+++ b/editeng/source/items/textitem.cxx
@@ -312,14 +312,14 @@ bool SvxFontItem::GetPresentation
 
 void SvxFontItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFontItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("familyName"), BAD_CAST(aFamilyName.toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("styleName"), BAD_CAST(aStyleName.toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("family"), BAD_CAST(OString::number(eFamily).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pitch"), BAD_CAST(OString::number(ePitch).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("textEncoding"), BAD_CAST(OString::number(eTextEncoding).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFontItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("familyName"), BAD_CAST(aFamilyName.toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("styleName"), BAD_CAST(aStyleName.toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("family"), BAD_CAST(OString::number(eFamily).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pitch"), BAD_CAST(OString::number(ePitch).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("textEncoding"), BAD_CAST(OString::number(eTextEncoding).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // class SvxPostureItem --------------------------------------------------
@@ -428,11 +428,11 @@ void SvxPostureItem::SetBoolValue( bool bVal )
 
 void SvxPostureItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxPostureItem"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%d", GetValue());
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(GetValueTextByPos(GetValue()).toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxPostureItem"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%d", GetValue());
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(GetValueTextByPos(GetValue()).toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // class SvxWeightItem ---------------------------------------------------
@@ -549,11 +549,11 @@ bool SvxWeightItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 
 void SvxWeightItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxWeightItem"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%d", GetValue());
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(GetValueTextByPos(GetValue()).toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxWeightItem"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%d", GetValue());
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(GetValueTextByPos(GetValue()).toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // class SvxFontHeightItem -----------------------------------------------
@@ -883,12 +883,12 @@ void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, sal_uInt16 nNewProp,
 
 void SvxFontHeightItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFontHeightItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("height"), BAD_CAST(OString::number(nHeight).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("prop"), BAD_CAST(OString::number(nProp).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("propUnit"), BAD_CAST(OString::number(static_cast<int>(ePropUnit)).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFontHeightItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("height"), BAD_CAST(OString::number(nHeight).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("prop"), BAD_CAST(OString::number(nProp).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("propUnit"), BAD_CAST(OString::number(static_cast<int>(ePropUnit)).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // class SvxTextLineItem ------------------------------------------------
@@ -1462,18 +1462,18 @@ bool SvxColorItem::GetPresentation
 
 void SvxColorItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxColorItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxColorItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
 
     std::stringstream ss;
     ss << mColor;
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(ss.str().c_str()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(ss.str().c_str()));
 
     OUString aStr;
     IntlWrapper aIntlWrapper(SvtSysLocale().GetUILanguageTag());
     GetPresentation( SfxItemPresentation::Complete, MapUnit::Map100thMM, MapUnit::Map100thMM, aStr, aIntlWrapper);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(OUStringToOString(aStr, RTL_TEXTENCODING_UTF8).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(OUStringToOString(aStr, RTL_TEXTENCODING_UTF8).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -2220,10 +2220,10 @@ bool SvxTextRotateItem::PutValue(const css::uno::Any& rVal, sal_uInt8 nMemberId)
 
 void SvxTextRotateItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxTextRotateItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue().get()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxTextRotateItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue().get()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -2310,11 +2310,11 @@ bool SvxCharRotateItem::operator==( const SfxPoolItem& rItem ) const
 
 void SvxCharRotateItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxCharRotateItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue().get()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("fitToLine"), BAD_CAST(OString::boolean(IsFitToLine()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxCharRotateItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue().get()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("fitToLine"), BAD_CAST(OString::boolean(IsFitToLine()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /*************************************************************************
@@ -2692,10 +2692,10 @@ bool SvxRsidItem::GetPresentation
 
 void SvxRsidItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxRsidItem"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%" SAL_PRIuUINT32, GetValue());
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxRsidItem"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%" SAL_PRIuUINT32, GetValue());
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/outliner/outliner.cxx b/editeng/source/outliner/outliner.cxx
index 7485b9ae1bc2..53fda5c1171c 100644
--- a/editeng/source/outliner/outliner.cxx
+++ b/editeng/source/outliner/outliner.cxx
@@ -2167,17 +2167,17 @@ void Outliner::dumpAsXml(xmlTextWriterPtr pWriter) const
         pWriter = xmlNewTextWriterFilename("outliner.xml", 0);
         xmlTextWriterSetIndent(pWriter,1);
         xmlTextWriterSetIndentString(pWriter, BAD_CAST("  "));
-        xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
+        (void)xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
         bOwns = true;
     }
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("Outliner"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("Outliner"));
     pParaList->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
     if (bOwns)
     {
-       xmlTextWriterEndDocument(pWriter);
+       (void)xmlTextWriterEndDocument(pWriter);
        xmlFreeTextWriter(pWriter);
     }
 }
diff --git a/editeng/source/outliner/outlobj.cxx b/editeng/source/outliner/outlobj.cxx
index f9d3479a8b2f..373fca12c5f1 100644
--- a/editeng/source/outliner/outlobj.cxx
+++ b/editeng/source/outliner/outlobj.cxx
@@ -232,12 +232,12 @@ void OutlinerParaObject::SetStyleSheets(sal_uInt16 nLevel, const OUString& rNewN
 
 void OutlinerParaObject::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("OutlinerParaObject"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("OutlinerParaObject"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
     mpImpl->mpEditTextObject->dumpAsXml(pWriter);
     for (ParagraphData const & p : mpImpl->maParagraphDataVector)
         Paragraph(p).dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/outliner/paralist.cxx b/editeng/source/outliner/paralist.cxx
index 1e560b56ca68..5b9f21449854 100644
--- a/editeng/source/outliner/paralist.cxx
+++ b/editeng/source/outliner/paralist.cxx
@@ -83,11 +83,11 @@ void Paragraph::SetParaIsNumberingRestart( bool bParaIsNumberingRestart )
 
 void Paragraph::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("Paragraph"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("nDepth"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(nDepth));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("mnNumberingStartValue"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(mnNumberingStartValue));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("mbParaIsNumberingRestart"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(mbParaIsNumberingRestart));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("Paragraph"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("nDepth"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(nDepth));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("mnNumberingStartValue"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(mnNumberingStartValue));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("mbParaIsNumberingRestart"), "%" SAL_PRIdINT32, static_cast<sal_Int32>(mbParaIsNumberingRestart));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void ParagraphList::Clear()
@@ -247,10 +247,10 @@ sal_Int32 ParagraphList::GetAbsPos( Paragraph const * pParent ) const
 
 void ParagraphList::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("ParagraphList"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("ParagraphList"));
     for (auto const & pParagraph : maEntries)
         pParagraph->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/core/data/attrib.cxx b/sc/source/core/data/attrib.cxx
index 105c95c6a7ae..0466ac44f7d9 100644
--- a/sc/source/core/data/attrib.cxx
+++ b/sc/source/core/data/attrib.cxx
@@ -115,11 +115,11 @@ ScMergeAttr* ScMergeAttr::Clone( SfxItemPool * ) const
 
 void ScMergeAttr::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("ScMergeAttr"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("col-merge"), BAD_CAST(OString::number(GetColMerge()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("row-merge"), BAD_CAST(OString::number(GetRowMerge()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("merged"), BAD_CAST(OString::boolean(IsMerged()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("ScMergeAttr"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("col-merge"), BAD_CAST(OString::number(GetColMerge()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("row-merge"), BAD_CAST(OString::number(GetRowMerge()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("merged"), BAD_CAST(OString::boolean(IsMerged()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /**
@@ -156,15 +156,15 @@ bool ScMergeFlagAttr::HasPivotPopupButton() const
 
 void ScMergeFlagAttr::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("ScMergeFlagAttr"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("overlapped"), BAD_CAST(OString::boolean(IsOverlapped()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("hor_overlapped"), BAD_CAST(OString::boolean(IsHorOverlapped()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("ver_overlapped"), BAD_CAST(OString::boolean(IsVerOverlapped()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("autofilter"), BAD_CAST(OString::boolean(HasAutoFilter()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("scenario"), BAD_CAST(OString::boolean(IsScenario()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pivot-button"), BAD_CAST(OString::boolean(HasPivotButton()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pivot-popup-button"), BAD_CAST(OString::boolean(HasPivotPopupButton()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("ScMergeFlagAttr"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("overlapped"), BAD_CAST(OString::boolean(IsOverlapped()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("hor_overlapped"), BAD_CAST(OString::boolean(IsHorOverlapped()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("ver_overlapped"), BAD_CAST(OString::boolean(IsVerOverlapped()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("autofilter"), BAD_CAST(OString::boolean(HasAutoFilter()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("scenario"), BAD_CAST(OString::boolean(IsScenario()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pivot-button"), BAD_CAST(OString::boolean(HasPivotButton()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pivot-popup-button"), BAD_CAST(OString::boolean(HasPivotPopupButton()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /**
@@ -716,14 +716,14 @@ ScCondFormatItem* ScCondFormatItem::Clone(SfxItemPool*) const
 
 void ScCondFormatItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("ScCondFormatItem"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("ScCondFormatItem"));
     for (const auto& nItem : maIndex)
     {
         std::string aStrVal = std::to_string(nItem);
-        xmlTextWriterStartElement(pWriter, BAD_CAST(aStrVal.c_str()));
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST(aStrVal.c_str()));
+        (void)xmlTextWriterEndElement(pWriter);
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 ScRotateValueItem::ScRotateValueItem(Degree100 nAngle)
diff --git a/sc/source/ui/view/gridwin_dbgutil.cxx b/sc/source/ui/view/gridwin_dbgutil.cxx
index fe4c6f594d2f..bcb1da5ff695 100644
--- a/sc/source/ui/view/gridwin_dbgutil.cxx
+++ b/sc/source/ui/view/gridwin_dbgutil.cxx
@@ -93,9 +93,9 @@ void ScGridWindow::dumpCellProperties()
     xmlTextWriterSetIndent(writer,1);
     xmlTextWriterSetIndentString(writer, BAD_CAST("    "));
 
-    xmlTextWriterStartDocument( writer, nullptr, nullptr, nullptr );
+    (void)xmlTextWriterStartDocument( writer, nullptr, nullptr, nullptr );
 
-    xmlTextWriterStartElement(writer, BAD_CAST("selection"));
+    (void)xmlTextWriterStartElement(writer, BAD_CAST("selection"));
 
     for (size_t i = 0, n = aList.size(); i < n; ++i)
     {
@@ -106,21 +106,21 @@ void ScGridWindow::dumpCellProperties()
             for (SCROW nRow = rRange.aStart.Row(); nRow <= rRange.aEnd.Row(); ++nRow)
             {
                 const ScPatternAttr* pPatternAttr = rDoc.GetPattern(nCol, nRow, nTab);
-                xmlTextWriterStartElement(writer, BAD_CAST("cell"));
-                xmlTextWriterWriteAttribute(writer, BAD_CAST("column"), BAD_CAST(OString::number(nCol).getStr()));
-                xmlTextWriterWriteAttribute(writer, BAD_CAST("row"), BAD_CAST(OString::number(nRow).getStr()));
-                xmlTextWriterWriteAttribute(writer, BAD_CAST("tab"), BAD_CAST(OString::number(nTab).getStr()));
+                (void)xmlTextWriterStartElement(writer, BAD_CAST("cell"));
+                (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("column"), BAD_CAST(OString::number(nCol).getStr()));
+                (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("row"), BAD_CAST(OString::number(nRow).getStr()));
+                (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("tab"), BAD_CAST(OString::number(nTab).getStr()));
 
                 pPatternAttr->GetItemSet().dumpAsXml(writer);
 
-                xmlTextWriterEndElement(writer);
+                (void)xmlTextWriterEndElement(writer);
             }
         }
     }
 
-    xmlTextWriterEndElement(writer);
+    (void)xmlTextWriterEndElement(writer);
 
-    xmlTextWriterEndDocument( writer );
+    (void)xmlTextWriterEndDocument( writer );
     xmlFreeTextWriter (writer);
 }
 
diff --git a/sd/qa/unit/tiledrendering/tiledrendering.cxx b/sd/qa/unit/tiledrendering/tiledrendering.cxx
index 3c7867d1b07a..cc11e2483991 100644
--- a/sd/qa/unit/tiledrendering/tiledrendering.cxx
+++ b/sd/qa/unit/tiledrendering/tiledrendering.cxx
@@ -354,7 +354,7 @@ xmlDocUniquePtr SdTiledRenderingTest::parseXmlDump()
     // Create the xml writer.
     m_pXmlBuffer = xmlBufferCreate();
     xmlTextWriterPtr pXmlWriter = xmlNewTextWriterMemory(m_pXmlBuffer, 0);
-    xmlTextWriterStartDocument(pXmlWriter, nullptr, nullptr, nullptr);
+    (void)xmlTextWriterStartDocument(pXmlWriter, nullptr, nullptr, nullptr);
 
     // Create the dump.
     SdXImpressDocument* pImpressDocument = dynamic_cast<SdXImpressDocument*>(mxComponent.get());
@@ -362,7 +362,7 @@ xmlDocUniquePtr SdTiledRenderingTest::parseXmlDump()
     pImpressDocument->GetDoc()->dumpAsXml(pXmlWriter);
 
     // Delete the xml writer.
-    xmlTextWriterEndDocument(pXmlWriter);
+    (void)xmlTextWriterEndDocument(pXmlWriter);
     xmlFreeTextWriter(pXmlWriter);
 
     return xmlDocUniquePtr(xmlParseMemory(reinterpret_cast<const char*>(xmlBufferContent(m_pXmlBuffer)), xmlBufferLength(m_pXmlBuffer)));
diff --git a/sd/source/core/drawdoc.cxx b/sd/source/core/drawdoc.cxx
index 48769e0b88da..182377c2dff7 100644
--- a/sd/source/core/drawdoc.cxx
+++ b/sd/source/core/drawdoc.cxx
@@ -1185,11 +1185,11 @@ void SdDrawDocument::dumpAsXml(xmlTextWriterPtr pWriter) const
         pWriter = xmlNewTextWriterFilename("model.xml", 0);
         xmlTextWriterSetIndent(pWriter,1);
         xmlTextWriterSetIndentString(pWriter, BAD_CAST("  "));
-        xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
+        (void)xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
         bOwns = true;
     }
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdDrawDocument"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdDrawDocument"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
     if (mpOutliner)
         mpOutliner->dumpAsXml(pWriter);
@@ -1197,10 +1197,10 @@ void SdDrawDocument::dumpAsXml(xmlTextWriterPtr pWriter) const
     if (GetUndoManager())
         GetUndoManager()->dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
     if (bOwns)
     {
-        xmlTextWriterEndDocument(pWriter);
+        (void)xmlTextWriterEndDocument(pWriter);
         xmlFreeTextWriter(pWriter);
     }
 }
diff --git a/sd/source/core/sdpage2.cxx b/sd/source/core/sdpage2.cxx
index dcb63d5e51ea..2719f3dea8f7 100644
--- a/sd/source/core/sdpage2.cxx
+++ b/sd/source/core/sdpage2.cxx
@@ -626,7 +626,7 @@ void SdPage::getGraphicsForPrefetch(std::vector<Graphic*>& graphics) const
 
 void SdPage::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdPage"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdPage"));
 
     const char* pPageKind = nullptr;
     switch (mePageKind)
@@ -642,11 +642,11 @@ void SdPage::dumpAsXml(xmlTextWriterPtr pWriter) const
         break;
     }
     if (pPageKind)
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("mePageKind"), BAD_CAST(pPageKind));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("mePageKind"), BAD_CAST(pPageKind));
 
 
     FmFormPage::dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/view/viewsh.cxx b/sfx2/source/view/viewsh.cxx
index 804a8da5da35..735da5c265e8 100644
--- a/sfx2/source/view/viewsh.cxx
+++ b/sfx2/source/view/viewsh.cxx
@@ -1575,10 +1575,10 @@ void SfxViewShell::NotifyOtherView(OutlinerViewShell* pOther, int nType, const O
 
 void SfxViewShell::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxViewShell"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("id"), BAD_CAST(OString::number(static_cast<sal_Int32>(GetViewShellId())).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxViewShell"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("id"), BAD_CAST(OString::number(static_cast<sal_Int32>(GetViewShellId())).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 bool SfxViewShell::KeyInput( const KeyEvent &rKeyEvent )
diff --git a/svl/source/items/cenumitm.cxx b/svl/source/items/cenumitm.cxx
index a2b62d132c23..5b3c57ed2272 100644
--- a/svl/source/items/cenumitm.cxx
+++ b/svl/source/items/cenumitm.cxx
@@ -107,10 +107,10 @@ bool SfxBoolItem::GetPresentation(SfxItemPresentation,
 
 void SfxBoolItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxBoolItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(GetValueTextByVal(m_bValue).toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxBoolItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(GetValueTextByVal(m_bValue).toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // virtual
diff --git a/svl/source/items/intitem.cxx b/svl/source/items/intitem.cxx
index e3850c8bf5a1..7535e665f795 100644
--- a/svl/source/items/intitem.cxx
+++ b/svl/source/items/intitem.cxx
@@ -100,10 +100,10 @@ SfxPoolItem* SfxUInt16Item::CreateDefault()
 
 void SfxUInt16Item::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxUInt16Item"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxUInt16Item"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 boost::property_tree::ptree SfxUInt16Item::dumpAsJSON() const
@@ -123,10 +123,10 @@ SfxPoolItem* SfxInt32Item::CreateDefault()
 
 void SfxInt32Item::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxInt32Item"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxInt32Item"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 boost::property_tree::ptree SfxInt32Item::dumpAsJSON() const
@@ -146,10 +146,10 @@ SfxPoolItem* SfxUInt32Item::CreateDefault()
 
 void SfxUInt32Item::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxUInt32Item"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxUInt32Item"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 boost::property_tree::ptree SfxUInt32Item::dumpAsJSON() const
diff --git a/svl/source/items/itempool.cxx b/svl/source/items/itempool.cxx
index 44c0cf534b5d..15f92acfcfd4 100644
--- a/svl/source/items/itempool.cxx
+++ b/svl/source/items/itempool.cxx
@@ -937,11 +937,11 @@ sal_uInt16 SfxItemPool::GetTrueSlotId( sal_uInt16 nWhich ) const
 
 void SfxItemPool::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxItemPool"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxItemPool"));
     for (auto const & rArray : pImpl->maPoolItemArrays)
         for (auto const & rItem : rArray)
             rItem->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svl/source/items/itemset.cxx b/svl/source/items/itemset.cxx
index 8d7b1e463911..883caf50d9d9 100644
--- a/svl/source/items/itemset.cxx
+++ b/svl/source/items/itemset.cxx
@@ -1503,11 +1503,11 @@ void SfxItemSet::PutDirect(const SfxPoolItem &rItem)
 
 void SfxItemSet::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxItemSet"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxItemSet"));
     SfxItemIter aIter(*this);
     for (const SfxPoolItem* pItem = aIter.GetCurItem(); pItem; pItem = aIter.NextItem())
          pItem->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
diff --git a/svl/source/items/poolitem.cxx b/svl/source/items/poolitem.cxx
index c6e3ad6c77d8..835bb911a930 100644
--- a/svl/source/items/poolitem.cxx
+++ b/svl/source/items/poolitem.cxx
@@ -539,17 +539,18 @@ bool SfxPoolItem::GetPresentation(
 
 void SfxPoolItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxPoolItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"),
-                                BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("typeName"), BAD_CAST(typeid(*this).name()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxPoolItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"),
+                                      BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("typeName"),
+                                      BAD_CAST(typeid(*this).name()));
     OUString rText;
     IntlWrapper aIntlWrapper(SvtSysLocale().GetUILanguageTag());
     if (GetPresentation(SfxItemPresentation::Complete, MapUnit::Map100thMM, MapUnit::Map100thMM,
                         rText, aIntlWrapper))
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"),
-                                    BAD_CAST(rText.toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"),
+                                          BAD_CAST(rText.toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 boost::property_tree::ptree SfxPoolItem::dumpAsJSON() const
@@ -591,10 +592,10 @@ bool SfxVoidItem::GetPresentation(SfxItemPresentation /*ePresentation*/, MapUnit
 
 void SfxVoidItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxVoidItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"),
-                                BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxVoidItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"),
+                                      BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SfxVoidItem* SfxVoidItem::Clone(SfxItemPool*) const { return new SfxVoidItem(*this); }
diff --git a/svl/source/items/stritem.cxx b/svl/source/items/stritem.cxx
index 86e2087cd503..c0ec01a9aba4 100644
--- a/svl/source/items/stritem.cxx
+++ b/svl/source/items/stritem.cxx
@@ -28,10 +28,10 @@ SfxStringItem* SfxStringItem::Clone(SfxItemPool *) const
 
 void SfxStringItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxStringItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(GetValue().toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxStringItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(GetValue().toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SfxPoolItem* SfxStringItem::CreateDefault()
diff --git a/svl/source/undo/undo.cxx b/svl/source/undo/undo.cxx
index 8d27145af335..71d7b6f254a7 100644
--- a/svl/source/undo/undo.cxx
+++ b/svl/source/undo/undo.cxx
@@ -124,13 +124,13 @@ bool SfxUndoAction::CanRepeat(SfxRepeatTarget&) const
 
 void SfxUndoAction::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxUndoAction"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("symbol"), BAD_CAST(typeid(*this).name()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("comment"), BAD_CAST(GetComment().toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("viewShellId"), BAD_CAST(OString::number(static_cast<sal_Int32>(GetViewShellId())).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("dateTime"), BAD_CAST(utl::toISO8601(m_aDateTime.GetUNODateTime()).toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxUndoAction"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("symbol"), BAD_CAST(typeid(*this).name()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("comment"), BAD_CAST(GetComment().toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("viewShellId"), BAD_CAST(OString::number(static_cast<sal_Int32>(GetViewShellId())).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("dateTime"), BAD_CAST(utl::toISO8601(m_aDateTime.GetUNODateTime()).toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 std::unique_ptr<SfxUndoAction> SfxUndoArray::Remove(int idx)
@@ -1147,34 +1147,34 @@ void SfxUndoManager::dumpAsXml(xmlTextWriterPtr pWriter) const
         pWriter = xmlNewTextWriterFilename("undo.xml", 0);
         xmlTextWriterSetIndent(pWriter,1);
         xmlTextWriterSetIndentString(pWriter, BAD_CAST("  "));
-        xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
+        (void)xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
         bOwns = true;
     }
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxUndoManager"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nUndoActionCount"), BAD_CAST(OString::number(GetUndoActionCount()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nRedoActionCount"), BAD_CAST(OString::number(GetRedoActionCount()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxUndoManager"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nUndoActionCount"), BAD_CAST(OString::number(GetUndoActionCount()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nRedoActionCount"), BAD_CAST(OString::number(GetRedoActionCount()).getStr()));
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("undoActions"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("undoActions"));
     for (size_t i = 0; i < GetUndoActionCount(); ++i)
     {
         const SfxUndoArray* pUndoArray = m_xData->pActUndoArray;
         pUndoArray->maUndoActions[pUndoArray->nCurUndoAction - 1 - i].pAction->dumpAsXml(pWriter);
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("redoActions"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("redoActions"));
     for (size_t i = 0; i < GetRedoActionCount(); ++i)
     {
         const SfxUndoArray* pUndoArray = m_xData->pActUndoArray;
         pUndoArray->maUndoActions[pUndoArray->nCurUndoAction + i].pAction->dumpAsXml(pWriter);
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
     if (bOwns)
     {
-        xmlTextWriterEndDocument(pWriter);
+        (void)xmlTextWriterEndDocument(pWriter);
         xmlFreeTextWriter(pWriter);
     }
 }
@@ -1363,14 +1363,14 @@ bool SfxListUndoAction::Merge( SfxUndoAction *pNextAction )
 
 void SfxListUndoAction::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SfxListUndoAction"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(OString::number(maUndoActions.size()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SfxListUndoAction"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(OString::number(maUndoActions.size()).getStr()));
     SfxUndoAction::dumpAsXml(pWriter);
 
     for (size_t i = 0; i < maUndoActions.size(); ++i)
         maUndoActions[i].pAction->dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SfxUndoArray::~SfxUndoArray()
diff --git a/svx/source/items/e3ditem.cxx b/svx/source/items/e3ditem.cxx
index e911ae20d756..cd61f9ac013a 100644
--- a/svx/source/items/e3ditem.cxx
+++ b/svx/source/items/e3ditem.cxx
@@ -89,12 +89,12 @@ bool SvxB3DVectorItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
 
 void SvxB3DVectorItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SvxB3DVectorItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("x"), BAD_CAST(OString::number(aVal.getX()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("y"), BAD_CAST(OString::number(aVal.getY()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("z"), BAD_CAST(OString::number(aVal.getZ()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxB3DVectorItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("x"), BAD_CAST(OString::number(aVal.getX()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("y"), BAD_CAST(OString::number(aVal.getY()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("z"), BAD_CAST(OString::number(aVal.getZ()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/sdr/properties/defaultproperties.cxx b/svx/source/sdr/properties/defaultproperties.cxx
index e9a9934a9973..40675946848d 100644
--- a/svx/source/sdr/properties/defaultproperties.cxx
+++ b/svx/source/sdr/properties/defaultproperties.cxx
@@ -244,10 +244,10 @@ namespace sdr::properties
 
         void DefaultProperties::dumpAsXml(xmlTextWriterPtr pWriter) const
         {
-            xmlTextWriterStartElement(pWriter, BAD_CAST("DefaultProperties"));
+            (void)xmlTextWriterStartElement(pWriter, BAD_CAST("DefaultProperties"));
             BaseProperties::dumpAsXml(pWriter);
             mpItemSet->dumpAsXml(pWriter);
-            xmlTextWriterEndElement(pWriter);
+            (void)xmlTextWriterEndElement(pWriter);
         }
 } // end of namespace
 
diff --git a/svx/source/sdr/properties/properties.cxx b/svx/source/sdr/properties/properties.cxx
index c3ffd1d86313..353cdc5ede36 100644
--- a/svx/source/sdr/properties/properties.cxx
+++ b/svx/source/sdr/properties/properties.cxx
@@ -155,8 +155,8 @@ namespace sdr::properties
 
         void BaseProperties::dumpAsXml(xmlTextWriterPtr pWriter) const
         {
-            xmlTextWriterStartElement(pWriter, BAD_CAST("BaseProperties"));
-            xmlTextWriterEndElement(pWriter);
+            (void)xmlTextWriterStartElement(pWriter, BAD_CAST("BaseProperties"));
+            (void)xmlTextWriterEndElement(pWriter);
         }
 
         void CleanupFillProperties( SfxItemSet& rItemSet )
diff --git a/svx/source/svdraw/svdattr.cxx b/svx/source/svdraw/svdattr.cxx
index 43c332a68029..4c1a43de57a1 100644
--- a/svx/source/svdraw/svdattr.cxx
+++ b/svx/source/svdraw/svdattr.cxx
@@ -729,15 +729,15 @@ bool SdrOnOffItem::GetPresentation(SfxItemPresentation ePres,
 
 void SdrOnOffItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdrOnOffItem"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrOnOffItem"));
     if (Which() == SDRATTR_SHADOW)
     {
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOW"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOW"));
     }
 
     SfxBoolItem::dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SdrYesNoItem* SdrYesNoItem::Clone(SfxItemPool* /*pPool*/) const
@@ -784,16 +784,16 @@ bool SdrPercentItem::GetPresentation(
 
 void SdrPercentItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdrPercentItem"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrPercentItem"));
     if (Which() == SDRATTR_SHADOWTRANSPARENCE)
     {
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"),
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"),
                                     BAD_CAST("SDRATTR_SHADOWTRANSPARENCE"));
     }
 
     SfxUInt16Item::dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SdrAngleItem* SdrAngleItem::Clone(SfxItemPool* /*pPool*/) const
@@ -893,31 +893,31 @@ bool SdrMetricItem::GetPresentation(SfxItemPresentation ePres,
 
 void SdrMetricItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdrMetricItem"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrMetricItem"));
     if (Which() == SDRATTR_SHADOWXDIST)
     {
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWXDIST"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWXDIST"));
     }
     else if (Which() == SDRATTR_SHADOWYDIST)
     {
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWYDIST"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWYDIST"));
     }
     else if (Which() == SDRATTR_SHADOWSIZEX)
     {
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWSIZEX"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWSIZEX"));
     }
     else if (Which() == SDRATTR_SHADOWSIZEY)
     {
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWSIZEY"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWSIZEY"));
     }
     else if (Which() == SDRATTR_SHADOWBLUR)
     {
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWBLUR"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWBLUR"));
     }
 
     SfxInt32Item::dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // items of the legend object
@@ -1110,10 +1110,10 @@ bool SdrTextVertAdjustItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberI
 
 void SdrTextVertAdjustItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdrTextVertAdjustItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrTextVertAdjustItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SdrTextHorzAdjustItem* SdrTextHorzAdjustItem::Clone(SfxItemPool* /*pPool*/) const            { return new SdrTextHorzAdjustItem(*this); }
diff --git a/svx/source/svdraw/svdmodel.cxx b/svx/source/svdraw/svdmodel.cxx
index 89633cf6af5c..f19d86e48334 100644
--- a/svx/source/svdraw/svdmodel.cxx
+++ b/svx/source/svdraw/svdmodel.cxx
@@ -1912,8 +1912,8 @@ void SdrModel::SetSdrUndoFactory( SdrUndoFactory* pUndoFactory )
 
 void SdrModel::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdrModel"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrModel"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
     sal_uInt16 nPageCount = GetPageCount();
     for (sal_uInt16 i = 0; i < nPageCount; ++i)
@@ -1922,7 +1922,7 @@ void SdrModel::dumpAsXml(xmlTextWriterPtr pWriter) const
             pPage->dumpAsXml(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 namespace
diff --git a/svx/source/svdraw/svdobj.cxx b/svx/source/svdraw/svdobj.cxx
index ce282769f997..9413f5152d47 100644
--- a/svx/source/svdraw/svdobj.cxx
+++ b/svx/source/svdraw/svdobj.cxx
@@ -1750,14 +1750,14 @@ bool SdrObject::Equals(const SdrObject& rOtherObj) const
 
 void SdrObject::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdrObject"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s", BAD_CAST(typeid(*this).name()));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("name"), "%s", BAD_CAST(GetName().toUtf8().getStr()));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("title"), "%s", BAD_CAST(GetTitle().toUtf8().getStr()));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("description"), "%s", BAD_CAST(GetDescription().toUtf8().getStr()));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("nOrdNum"), "%" SAL_PRIuUINT32, GetOrdNumDirect());
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aOutRect"), BAD_CAST(aOutRect.toString().getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrObject"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s", BAD_CAST(typeid(*this).name()));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("name"), "%s", BAD_CAST(GetName().toUtf8().getStr()));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("title"), "%s", BAD_CAST(GetTitle().toUtf8().getStr()));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("description"), "%s", BAD_CAST(GetDescription().toUtf8().getStr()));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("nOrdNum"), "%" SAL_PRIuUINT32, GetOrdNumDirect());
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aOutRect"), BAD_CAST(aOutRect.toString().getStr()));
 
     if (pGrabBagItem)
     {
@@ -1772,7 +1772,7 @@ void SdrObject::dumpAsXml(xmlTextWriterPtr pWriter) const
     if (const OutlinerParaObject* pOutliner = GetOutlinerParaObject())
         pOutliner->dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void SdrObject::SetOutlinerParaObject(std::unique_ptr<OutlinerParaObject> pTextObject)
diff --git a/svx/source/svdraw/svdogrp.cxx b/svx/source/svdraw/svdogrp.cxx
index 1242ec6a5cf4..67783b147c3e 100644
--- a/svx/source/svdraw/svdogrp.cxx
+++ b/svx/source/svdraw/svdogrp.cxx
@@ -775,13 +775,13 @@ SdrObjectUniquePtr SdrObjGroup::DoConvertToPolyObj(bool bBezier, bool bAddText)
 
 void SdrObjGroup::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdrObjGroup"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrObjGroup"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
     SdrObject::dumpAsXml(pWriter);
     SdrObjList::dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/svdraw/svdpage.cxx b/svx/source/svdraw/svdpage.cxx
index c614928f2537..91080e9be5ff 100644
--- a/svx/source/svdraw/svdpage.cxx
+++ b/svx/source/svdraw/svdpage.cxx
@@ -1059,9 +1059,9 @@ void SdrObjList::RemoveObjectFromContainer (
 
 void SdrObjList::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdrObjList"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s", BAD_CAST(typeid(*this).name()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrObjList"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s", BAD_CAST(typeid(*this).name()));
 
     size_t nObjCount = GetObjCount();
     for (size_t i = 0; i < nObjCount; ++i)
@@ -1070,7 +1070,7 @@ void SdrObjList::dumpAsXml(xmlTextWriterPtr pWriter) const
             pObject->dumpAsXml(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
diff --git a/svx/source/svdraw/svdtext.cxx b/svx/source/svdraw/svdtext.cxx
index 163453c0882f..94c84dcb4974 100644
--- a/svx/source/svdraw/svdtext.cxx
+++ b/svx/source/svdraw/svdtext.cxx
@@ -138,9 +138,9 @@ SfxStyleSheet* SdrText::GetStyleSheet() const
 
 void SdrText::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdrText"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrText"));
     mpOutlinerParaObject->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/table/cell.cxx b/svx/source/table/cell.cxx
index 3bc253b48b71..06c9fda21a39 100644
--- a/svx/source/table/cell.cxx
+++ b/svx/source/table/cell.cxx
@@ -1686,14 +1686,14 @@ void SAL_CALL Cell::disposing( const EventObject& /*Source*/ )
 
 void Cell::dumpAsXml(xmlTextWriterPtr pWriter, sal_Int32 nRow, sal_Int32 nCol) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("Cell"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("row"), "%" SAL_PRIdINT32, nRow);
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("col"), "%" SAL_PRIdINT32, nCol);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("Cell"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("row"), "%" SAL_PRIdINT32, nRow);
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("col"), "%" SAL_PRIdINT32, nCol);
     SdrText::dumpAsXml(pWriter);
     //SvxUnoTextBase::dumpAsXml(pWriter);
     //mpPropSet->dumpAsXml(pWriter);
     mpProperties->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 }
diff --git a/svx/source/table/svdotable.cxx b/svx/source/table/svdotable.cxx
index f3d4ae4d5728..66be795a8817 100644
--- a/svx/source/table/svdotable.cxx
+++ b/svx/source/table/svdotable.cxx
@@ -734,11 +734,11 @@ bool SdrTableObjImpl::isInUse()
 
 void SdrTableObjImpl::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdrTableObjImpl"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrTableObjImpl"));
     if (mpLayouter)
         mpLayouter->dumpAsXml(pWriter);
     mxTable->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -2443,14 +2443,14 @@ void SdrTableObj::uno_unlock()
 
 void SdrTableObj::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SdrTableObj"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrTableObj"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
     SdrObject::dumpAsXml(pWriter);
 
     mpImpl->dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 bool SdrTableObj::createTableEdgesJson(boost::property_tree::ptree & rJsonRoot)
diff --git a/svx/source/table/tablelayouter.cxx b/svx/source/table/tablelayouter.cxx
index 2d8de0c1f8e2..ed944fb3c1e1 100644
--- a/svx/source/table/tablelayouter.cxx
+++ b/svx/source/table/tablelayouter.cxx
@@ -1311,30 +1311,30 @@ void TableLayouter::DistributeRows( ::tools::Rectangle& rArea,
 
 void TableLayouter::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("TableLayouter"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("TableLayouter"));
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("columns"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("columns"));
     for (const auto& rColumn : maColumns)
         rColumn.dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("rows"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("rows"));
     for (const auto& rRow : maRows)
         rRow.dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void TableLayouter::Layout::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("TableLayouter_Layout"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("TableLayouter_Layout"));
 
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pos"), BAD_CAST(OString::number(mnPos).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(OString::number(mnSize).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("minSize"), BAD_CAST(OString::number(mnMinSize).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pos"), BAD_CAST(OString::number(mnPos).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(OString::number(mnSize).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("minSize"), BAD_CAST(OString::number(mnMinSize).getStr()));
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 }
diff --git a/svx/source/table/tablemodel.cxx b/svx/source/table/tablemodel.cxx
index a6d21f3935db..2ede658f6a40 100644
--- a/svx/source/table/tablemodel.cxx
+++ b/svx/source/table/tablemodel.cxx
@@ -1113,13 +1113,13 @@ void TableModel::updateColumns()
 
 void TableModel::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("TableModel"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("TableModel"));
     for (sal_Int32 nRow = 0; nRow < getRowCountImpl(); ++nRow)
         for (sal_Int32 nCol = 0; nCol < getColumnCountImpl(); ++nCol)
         {
             maRows[nRow]->maCells[nCol]->dumpAsXml(pWriter, nRow, nCol);
         }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 }
diff --git a/svx/source/xoutdev/xattr.cxx b/svx/source/xoutdev/xattr.cxx
index 8efd50c25418..27f11861e927 100644
--- a/svx/source/xoutdev/xattr.cxx
+++ b/svx/source/xoutdev/xattr.cxx
@@ -247,12 +247,12 @@ OUString NameOrIndex::CheckNamedItem( const NameOrIndex* pCheckItem, const sal_u
 
 void NameOrIndex::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("NameOrIndex"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("isIndex"), BAD_CAST(OString::boolean(IsIndex()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"), BAD_CAST(OString::number(nPalIndex).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("NameOrIndex"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("isIndex"), BAD_CAST(OString::boolean(IsIndex()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"), BAD_CAST(OString::number(nPalIndex).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SfxPoolItem* XColorItem::CreateDefault() { return new XColorItem; }
@@ -316,17 +316,17 @@ bool XColorItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
 
 void XColorItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("XColorItem"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XColorItem"));
     if (Which() == SDRATTR_SHADOWCOLOR)
     {
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWCOLOR"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWCOLOR"));
     }
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aColor"),
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aColor"),
                                 BAD_CAST(aColor.AsRGBHexString().toUtf8().getStr()));
 
     NameOrIndex::dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // --- line attributes ---
@@ -1816,16 +1816,16 @@ bool XFillStyleItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*
 
 void XFillStyleItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("XFillStyleItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(static_cast<sal_Int16>(GetValue())).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillStyleItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(static_cast<sal_Int16>(GetValue())).getStr()));
 
     OUString aPresentation;
     IntlWrapper aIntlWrapper(SvtSysLocale().GetUILanguageTag());
     GetPresentation(SfxItemPresentation::Nameless, MapUnit::Map100thMM, MapUnit::Map100thMM, aPresentation, aIntlWrapper);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(aPresentation.toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(aPresentation.toUtf8().getStr()));
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 boost::property_tree::ptree XFillStyleItem::dumpAsJSON() const
@@ -1911,10 +1911,10 @@ bool XFillColorItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*
 
 void XFillColorItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("XFillColorItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(GetColorValue().AsRGBHexString().toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillColorItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(GetColorValue().AsRGBHexString().toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 boost::property_tree::ptree XFillColorItem::dumpAsJSON() const
diff --git a/svx/source/xoutdev/xattr2.cxx b/svx/source/xoutdev/xattr2.cxx
index d4c0b5022ff9..f64230ef8134 100644
--- a/svx/source/xoutdev/xattr2.cxx
+++ b/svx/source/xoutdev/xattr2.cxx
@@ -363,10 +363,10 @@ bool XFillTransparenceItem::GetPresentation
 
 void XFillTransparenceItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("XFillTransparenceItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillTransparenceItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -430,10 +430,10 @@ bool XFillBmpTileItem::GetPresentation
 
 void XFillBmpTileItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBmpTileItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBmpTileItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -467,10 +467,10 @@ sal_uInt16 XFillBmpPosItem::GetValueCount() const
 
 void XFillBmpPosItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBmpPosItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(static_cast<int>(GetValue())).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBmpPosItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(static_cast<int>(GetValue())).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
@@ -624,10 +624,10 @@ bool XFillBmpStretchItem::GetPresentation
 
 void XFillBmpStretchItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBmpStretchItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBmpStretchItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
diff --git a/svx/source/xoutdev/xattrbmp.cxx b/svx/source/xoutdev/xattrbmp.cxx
index 4288c9607e5e..b0f3e7ee49c3 100644
--- a/svx/source/xoutdev/xattrbmp.cxx
+++ b/svx/source/xoutdev/xattrbmp.cxx
@@ -331,12 +331,12 @@ std::unique_ptr<XFillBitmapItem> XFillBitmapItem::checkForUniqueItem( SdrModel*
 
 void XFillBitmapItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBitmapItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBitmapItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
 
     NameOrIndex::dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/qa/core/uwriter.cxx b/sw/qa/core/uwriter.cxx
index 5c872bb5ebf5..5a9ae1b04ac5 100644
--- a/sw/qa/core/uwriter.cxx
+++ b/sw/qa/core/uwriter.cxx
@@ -1185,9 +1185,9 @@ void SwDocTest::randomTest()
 
         xmlTextWriterPtr writer;
         writer = xmlNewTextWriterFilename( aBuffer.makeStringAndClear().getStr(), 0 );
-        xmlTextWriterStartDocument( writer, NULL, NULL, NULL );
+        (void)xmlTextWriterStartDocument( writer, NULL, NULL, NULL );
         m_pDoc->dumpAsXml(writer);
-        xmlTextWriterEndDocument( writer );
+        (void)xmlTextWriterEndDocument( writer );
         xmlFreeTextWriter( writer );
 #endif
     }
diff --git a/sw/qa/unit/swmodeltestbase.cxx b/sw/qa/unit/swmodeltestbase.cxx
index 389809346d37..53d8d0a71b77 100644
--- a/sw/qa/unit/swmodeltestbase.cxx
+++ b/sw/qa/unit/swmodeltestbase.cxx
@@ -144,7 +144,7 @@ void SwModelTestBase::dumpLayout(const uno::Reference<lang::XComponent>& rCompon
     // create the xml writer
     mpXmlBuffer = xmlBufferCreate();
     xmlTextWriterPtr pXmlWriter = xmlNewTextWriterMemory(mpXmlBuffer, 0);
-    xmlTextWriterStartDocument(pXmlWriter, nullptr, nullptr, nullptr);
+    (void)xmlTextWriterStartDocument(pXmlWriter, nullptr, nullptr, nullptr);
 
     // create the dump
     SwXTextDocument* pTextDoc = dynamic_cast<SwXTextDocument*>(rComponent.get());
@@ -154,7 +154,7 @@ void SwModelTestBase::dumpLayout(const uno::Reference<lang::XComponent>& rCompon
     pLayout->dumpAsXml(pXmlWriter);
 
     // delete xml writer
-    xmlTextWriterEndDocument(pXmlWriter);
+    (void)xmlTextWriterEndDocument(pXmlWriter);
     xmlFreeTextWriter(pXmlWriter);
 }
 
diff --git a/sw/source/core/attr/fmtwrapinfluenceonobjpos.cxx b/sw/source/core/attr/fmtwrapinfluenceonobjpos.cxx
index 21ceec2f0e68..8f9abd96c775 100644
--- a/sw/source/core/attr/fmtwrapinfluenceonobjpos.cxx
+++ b/sw/source/core/attr/fmtwrapinfluenceonobjpos.cxx
@@ -164,11 +164,11 @@ SwTwips SwFormatWrapInfluenceOnObjPos::GetOverlapVertOffset() const { return mnO
 
 void SwFormatWrapInfluenceOnObjPos::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatWrapInfluenceOnObjPos"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWrapInfluenceOnPosition"), BAD_CAST(OString::number(mnWrapInfluenceOnPosition).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("mbAllowOverlap"), BAD_CAST(OString::boolean(mbAllowOverlap).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatWrapInfluenceOnObjPos"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWrapInfluenceOnPosition"), BAD_CAST(OString::number(mnWrapInfluenceOnPosition).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("mbAllowOverlap"), BAD_CAST(OString::boolean(mbAllowOverlap).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/bastyp/swrect.cxx b/sw/source/core/bastyp/swrect.cxx
index 3809c2113c04..a12b4aa92c34 100644
--- a/sw/source/core/bastyp/swrect.cxx
+++ b/sw/source/core/bastyp/swrect.cxx
@@ -220,12 +220,12 @@ void SwRect::SetLowerLeftCorner(  const Point& rNew )
 
 void SwRect::dumpAsXmlAttributes(xmlTextWriterPtr writer) const
 {
-    xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("left"), "%li", Left());
-    xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("top"), "%li", Top());
-    xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("width"), "%li", Width());
-    xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("height"), "%li", Height());
-    xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("bottom"), "%li", Bottom());
-    xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("right"), "%li", Right());
+    (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("left"), "%li", Left());
+    (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("top"), "%li", Top());
+    (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("width"), "%li", Width());
+    (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("height"), "%li", Height());
+    (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("bottom"), "%li", Bottom());
+    (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("right"), "%li", Right());
 }
 
 #ifdef DBG_UTIL
diff --git a/sw/source/core/crsr/bookmrk.cxx b/sw/source/core/crsr/bookmrk.cxx
index 254ca1c4ec52..ee03e6bc28b7 100644
--- a/sw/source/core/crsr/bookmrk.cxx
+++ b/sw/source/core/crsr/bookmrk.cxx
@@ -297,18 +297,18 @@ namespace sw::mark
 
     void MarkBase::dumpAsXml(xmlTextWriterPtr pWriter) const
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("MarkBase"));
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(m_aName.toUtf8().getStr()));
-        xmlTextWriterStartElement(pWriter, BAD_CAST("markPos"));
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("MarkBase"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(m_aName.toUtf8().getStr()));
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("markPos"));
         GetMarkPos().dumpAsXml(pWriter);
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
         if (IsExpanded())
         {
-            xmlTextWriterStartElement(pWriter, BAD_CAST("otherMarkPos"));
+            (void)xmlTextWriterStartElement(pWriter, BAD_CAST("otherMarkPos"));
             GetOtherMarkPos().dumpAsXml(pWriter);
-            xmlTextWriterEndElement(pWriter);
+            (void)xmlTextWriterEndElement(pWriter);
         }
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
 
     MarkBase::~MarkBase()
@@ -526,20 +526,20 @@ namespace sw::mark
 
     void Fieldmark::dumpAsXml(xmlTextWriterPtr pWriter) const
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("Fieldmark"));
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("fieldname"), BAD_CAST(m_aFieldname.toUtf8().getStr()));
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("fieldHelptext"), BAD_CAST(m_aFieldHelptext.toUtf8().getStr()));
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("Fieldmark"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("fieldname"), BAD_CAST(m_aFieldname.toUtf8().getStr()));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("fieldHelptext"), BAD_CAST(m_aFieldHelptext.toUtf8().getStr()));
         MarkBase::dumpAsXml(pWriter);
-        xmlTextWriterStartElement(pWriter, BAD_CAST("parameters"));
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("parameters"));
         for (auto& rParam : m_vParams)
         {
-            xmlTextWriterStartElement(pWriter, BAD_CAST("parameter"));
-            xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(rParam.first.toUtf8().getStr()));
-            xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(comphelper::anyToString(rParam.second).toUtf8().getStr()));
-            xmlTextWriterEndElement(pWriter);
+            (void)xmlTextWriterStartElement(pWriter, BAD_CAST("parameter"));
+            (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(rParam.first.toUtf8().getStr()));
+            (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(comphelper::anyToString(rParam.second).toUtf8().getStr()));
+            (void)xmlTextWriterEndElement(pWriter);
         }
-        xmlTextWriterEndElement(pWriter);
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
 
     TextFieldmark::TextFieldmark(const SwPaM& rPaM, const OUString& rName)
diff --git a/sw/source/core/crsr/crsrsh.cxx b/sw/source/core/crsr/crsrsh.cxx
index bb62e4b535f1..64a9d34906e2 100644
--- a/sw/source/core/crsr/crsrsh.cxx
+++ b/sw/source/core/crsr/crsrsh.cxx
@@ -3648,16 +3648,16 @@ OUString SwCursorShell::GetCursorDescr() const
 
 void SwCursorShell::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwCursorShell"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwCursorShell"));
 
     SwViewShell::dumpAsXml(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_pCurrentCursor"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_pCurrentCursor"));
     for (const SwPaM& rPaM : m_pCurrentCursor->GetRingContainer())
         rPaM.dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 static void lcl_FillRecognizerData( std::vector< OUString >& rSmartTagTypes,
diff --git a/sw/source/core/crsr/pam.cxx b/sw/source/core/crsr/pam.cxx
index 1b9b73e2faf8..f6e55168315a 100644
--- a/sw/source/core/crsr/pam.cxx
+++ b/sw/source/core/crsr/pam.cxx
@@ -185,10 +185,10 @@ SwDoc& SwPosition::GetDoc() const
 
 void SwPosition::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwPosition"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nNode"), BAD_CAST(OString::number(nNode.GetIndex()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nContent"), BAD_CAST(OString::number(nContent.GetIndex()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwPosition"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nNode"), BAD_CAST(OString::number(nNode.GetIndex()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nContent"), BAD_CAST(OString::number(nContent.GetIndex()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 std::ostream &operator <<(std::ostream& s, const SwPosition& position)
@@ -1150,20 +1150,20 @@ void SwPaM::InvalidatePaM()
 
 void SwPaM::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwPaM"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwPaM"));
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("point"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("point"));
     GetPoint()->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
     if (HasMark())
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("mark"));
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mark"));
         GetMark()->dumpAsXml(pWriter);
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 std::ostream &operator <<(std::ostream& s, const SwPaM& pam)
diff --git a/sw/source/core/doc/DocumentSettingManager.cxx b/sw/source/core/doc/DocumentSettingManager.cxx
index 98f53bc6b931..928160b07b91 100644
--- a/sw/source/core/doc/DocumentSettingManager.cxx
+++ b/sw/source/core/doc/DocumentSettingManager.cxx
@@ -690,297 +690,297 @@ void sw::DocumentSettingManager::Setn32DummyCompatibilityOptions2( const sal_uIn
 
 void sw::DocumentSettingManager::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("DocumentSettingManager"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("DocumentSettingManager"));
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbHTMLMode"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbHTMLMode"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbHTMLMode).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbIsGlobalDoc"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbIsGlobalDoc"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbIsGlobalDoc).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbGlblDocSaveLinks"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbGlblDocSaveLinks"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbGlblDocSaveLinks).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbIsLabelDoc"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbIsLabelDoc"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbIsLabelDoc).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbPurgeOLE"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbPurgeOLE"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbPurgeOLE).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbKernAsianPunctuation"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbKernAsianPunctuation"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbKernAsianPunctuation).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbParaSpaceMax"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbParaSpaceMax"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbParaSpaceMax).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbParaSpaceMaxAtPages"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbParaSpaceMaxAtPages"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbParaSpaceMaxAtPages).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbTabCompat"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbTabCompat"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbTabCompat).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbUseVirtualDevice"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbUseVirtualDevice"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbUseVirtualDevice).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbAddFlyOffsets"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbAddFlyOffsets"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbAddFlyOffsets).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbAddVerticalFlyOffsets"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbAddVerticalFlyOffsets"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbAddVerticalFlyOffsets).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbAddExternalLeading"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbAddExternalLeading"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbAddExternalLeading).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbUseHiResolutionVirtualDevice"));
-    xmlTextWriterWriteAttribute(
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbUseHiResolutionVirtualDevice"));
+    (void)xmlTextWriterWriteAttribute(
         pWriter, BAD_CAST("value"),
         BAD_CAST(OString::boolean(mbUseHiResolutionVirtualDevice).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbOldLineSpacing"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbOldLineSpacing"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbOldLineSpacing).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbAddParaSpacingToTableCells"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbAddParaSpacingToTableCells"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbAddParaSpacingToTableCells).getStr()));
-    xmlTextWriterEndElement(pWriter);
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbAddParaLineSpacingToTableCells"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbAddParaLineSpacingToTableCells"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbAddParaLineSpacingToTableCells).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbUseFormerObjectPos"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbUseFormerObjectPos"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbUseFormerObjectPos).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbUseFormerTextWrapping"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbUseFormerTextWrapping"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbUseFormerTextWrapping).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbConsiderWrapOnObjPos"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbConsiderWrapOnObjPos"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbConsiderWrapOnObjPos).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbMathBaselineAlignment"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbMathBaselineAlignment"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbMathBaselineAlignment).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbStylesNoDefault"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbStylesNoDefault"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbStylesNoDefault).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbFloattableNomargins"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbFloattableNomargins"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbFloattableNomargins).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbOldNumbering"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbOldNumbering"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbOldNumbering).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbIgnoreFirstLineIndentInNumbering"));
-    xmlTextWriterWriteAttribute(
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbIgnoreFirstLineIndentInNumbering"));
+    (void)xmlTextWriterWriteAttribute(
         pWriter, BAD_CAST("value"),
         BAD_CAST(OString::boolean(mbIgnoreFirstLineIndentInNumbering).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbDoNotJustifyLinesWithManualBreak"));
-    xmlTextWriterWriteAttribute(
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbDoNotJustifyLinesWithManualBreak"));
+    (void)xmlTextWriterWriteAttribute(
         pWriter, BAD_CAST("value"),
         BAD_CAST(OString::boolean(mbDoNotJustifyLinesWithManualBreak).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbDoNotResetParaAttrsForNumFont"));
-    xmlTextWriterWriteAttribute(
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbDoNotResetParaAttrsForNumFont"));
+    (void)xmlTextWriterWriteAttribute(
         pWriter, BAD_CAST("value"),
         BAD_CAST(OString::boolean(mbDoNotResetParaAttrsForNumFont).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbTableRowKeep"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbTableRowKeep"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbTableRowKeep).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbIgnoreTabsAndBlanksForLineCalculation"));
-    xmlTextWriterWriteAttribute(
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbIgnoreTabsAndBlanksForLineCalculation"));
+    (void)xmlTextWriterWriteAttribute(
         pWriter, BAD_CAST("value"),
         BAD_CAST(OString::boolean(mbIgnoreTabsAndBlanksForLineCalculation).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbDoNotCaptureDrawObjsOnPage"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbDoNotCaptureDrawObjsOnPage"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbDoNotCaptureDrawObjsOnPage).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbClipAsCharacterAnchoredWriterFlyFrames"));
-    xmlTextWriterWriteAttribute(
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbClipAsCharacterAnchoredWriterFlyFrames"));
+    (void)xmlTextWriterWriteAttribute(
         pWriter, BAD_CAST("value"),
         BAD_CAST(OString::boolean(mbClipAsCharacterAnchoredWriterFlyFrames).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbUnixForceZeroExtLeading"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbUnixForceZeroExtLeading"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbUnixForceZeroExtLeading).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbTabRelativeToIndent"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbTabRelativeToIndent"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbTabRelativeToIndent).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbProtectForm"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbProtectForm"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbProtectForm).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbMsWordCompTrailingBlanks"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbMsWordCompTrailingBlanks"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbMsWordCompTrailingBlanks).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbMsWordCompMinLineHeightByFly"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbMsWordCompMinLineHeightByFly"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbMsWordCompMinLineHeightByFly).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbInvertBorderSpacing"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbInvertBorderSpacing"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbInvertBorderSpacing).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbCollapseEmptyCellPara"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbCollapseEmptyCellPara"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbCollapseEmptyCellPara).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbTabAtLeftIndentForParagraphsInList"));
-    xmlTextWriterWriteAttribute(
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbTabAtLeftIndentForParagraphsInList"));
+    (void)xmlTextWriterWriteAttribute(
         pWriter, BAD_CAST("value"),
         BAD_CAST(OString::boolean(mbTabAtLeftIndentForParagraphsInList).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbSmallCapsPercentage66"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbSmallCapsPercentage66"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbSmallCapsPercentage66).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbTabOverflow"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbTabOverflow"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbTabOverflow).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbUnbreakableNumberings"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbUnbreakableNumberings"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbUnbreakableNumberings).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbClippedPictures"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbClippedPictures"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbClippedPictures).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbBackgroundParaOverDrawings"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbBackgroundParaOverDrawings"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbBackgroundParaOverDrawings).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbTabOverMargin"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbTabOverMargin"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbTabOverMargin).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbTreatSingleColumnBreakAsPageBreak"));
-    xmlTextWriterWriteAttribute(
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbTreatSingleColumnBreakAsPageBreak"));
+    (void)xmlTextWriterWriteAttribute(
         pWriter, BAD_CAST("value"),
         BAD_CAST(OString::boolean(mbTreatSingleColumnBreakAsPageBreak).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbSurroundTextWrapSmall"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbSurroundTextWrapSmall"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbSurroundTextWrapSmall).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbPropLineSpacingShrinksFirstLine"));
-    xmlTextWriterWriteAttribute(
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbPropLineSpacingShrinksFirstLine"));
+    (void)xmlTextWriterWriteAttribute(
         pWriter, BAD_CAST("value"),
         BAD_CAST(OString::boolean(mbPropLineSpacingShrinksFirstLine).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbSubtractFlys"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbSubtractFlys"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbSubtractFlys).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbLastBrowseMode"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbLastBrowseMode"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbLastBrowseMode).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbDisableOffPagePositioning"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbDisableOffPagePositioning"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbDisableOffPagePositioning).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbEmptyDbFieldHidesPara"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbEmptyDbFieldHidesPara"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbEmptyDbFieldHidesPara).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbContinuousEndnotes"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbContinuousEndnotes"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbContinuousEndnotes).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbHeaderSpacingBelowLastPara"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbHeaderSpacingBelowLastPara"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbHeaderSpacingBelowLastPara).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbFrameAutowidthWithMorePara"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbFrameAutowidthWithMorePara"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
         BAD_CAST(OString::boolean(mbFrameAutowidthWithMorePara).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbGutterAtTop"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbGutterAtTop"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::boolean(mbGutterAtTop).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/doc/docbm.cxx b/sw/source/core/doc/docbm.cxx
index 438c294c5ecd..d09bcb6e6046 100644
--- a/sw/source/core/doc/docbm.cxx
+++ b/sw/source/core/doc/docbm.cxx
@@ -1766,18 +1766,18 @@ void MarkManager::dumpAsXml(xmlTextWriterPtr pWriter) const
         {"annotationmarks", &m_vAnnotationMarks}
     };
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("MarkManager"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("MarkManager"));
     for (const auto & rContainer : aContainers)
     {
         if (!rContainer.pContainer->empty())
         {
-            xmlTextWriterStartElement(pWriter, BAD_CAST(rContainer.pName));
+            (void)xmlTextWriterStartElement(pWriter, BAD_CAST(rContainer.pName));
             for (auto it = rContainer.pContainer->begin(); it != rContainer.pContainer->end(); ++it)
                 (*it)->dumpAsXml(pWriter);
-            xmlTextWriterEndElement(pWriter);
+            (void)xmlTextWriterEndElement(pWriter);
         }
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 } // namespace ::sw::mark
diff --git a/sw/source/core/doc/docfmt.cxx b/sw/source/core/doc/docfmt.cxx
index 2ded69b4ae4c..ee4854e142e0 100644
--- a/sw/source/core/doc/docfmt.cxx
+++ b/sw/source/core/doc/docfmt.cxx
@@ -1936,11 +1936,11 @@ void SwDoc::dumpAsXml(xmlTextWriterPtr pWriter) const
         pWriter = xmlNewTextWriterFilename("nodes.xml", 0);
         xmlTextWriterSetIndent(pWriter,1);
         xmlTextWriterSetIndentString(pWriter, BAD_CAST("  "));
-        xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
+        (void)xmlTextWriterStartDocument(pWriter, nullptr, nullptr, nullptr);
         bOwns = true;
     }
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwDoc"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwDoc"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
     m_pNodes->dumpAsXml(pWriter);
     m_PageDescs.dumpAsXml(pWriter);
@@ -1961,27 +1961,27 @@ void SwDoc::dumpAsXml(xmlTextWriterPtr pWriter) const
     if (const SdrModel* pModel = getIDocumentDrawModelAccess().GetDrawModel())
         pModel->dumpAsXml(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mbModified"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(getIDocumentState().IsModified()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mbModified"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(getIDocumentState().IsModified()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
     if (bOwns)
     {
-        xmlTextWriterEndDocument(pWriter);
+        (void)xmlTextWriterEndDocument(pWriter);
         xmlFreeTextWriter(pWriter);
     }
 }
 
 void SwDBData::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwDBData"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwDBData"));
 
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("sDataSource"), BAD_CAST(sDataSource.toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("sCommand"), BAD_CAST(sCommand.toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nCommandType"), BAD_CAST(OString::number(nCommandType).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("sDataSource"), BAD_CAST(sDataSource.toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("sCommand"), BAD_CAST(sCommand.toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nCommandType"), BAD_CAST(OString::number(nCommandType).getStr()));
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 std::set<Color> SwDoc::GetDocColors()
diff --git a/sw/source/core/doc/docredln.cxx b/sw/source/core/doc/docredln.cxx
index 1eed6d70ce2e..a378203b8962 100644
--- a/sw/source/core/doc/docredln.cxx
+++ b/sw/source/core/doc/docredln.cxx
@@ -87,18 +87,18 @@ SwExtraRedlineTable::~SwExtraRedlineTable()
 
 void SwExtraRedlineTable::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwExtraRedlineTable"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwExtraRedlineTable"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
     for (sal_uInt16 nCurExtraRedlinePos = 0; nCurExtraRedlinePos < GetSize(); ++nCurExtraRedlinePos)
     {
         const SwExtraRedline* pExtraRedline = GetRedline(nCurExtraRedlinePos);
-        xmlTextWriterStartElement(pWriter, BAD_CAST("SwExtraRedline"));
-        xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-        xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s", BAD_CAST(typeid(*pExtraRedline).name()));
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwExtraRedline"));
+        (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+        (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s", BAD_CAST(typeid(*pExtraRedline).name()));
+        (void)xmlTextWriterEndElement(pWriter);
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 #if OSL_DEBUG_LEVEL > 0
@@ -738,13 +738,13 @@ const SwRangeRedline* SwRedlineTable::FindAtPosition( const SwPosition& rSttPos,
 
 void SwRedlineTable::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwRedlineTable"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwRedlineTable"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
     for (SwRedlineTable::size_type nCurRedlinePos = 0; nCurRedlinePos < size(); ++nCurRedlinePos)
         operator[](nCurRedlinePos)->dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SwRedlineExtraData::~SwRedlineExtraData()
@@ -1900,13 +1900,13 @@ OUString SwRangeRedline::GetDescr(bool bSimplified)
 
 void SwRangeRedline::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwRangeRedline"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwRangeRedline"));
 
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("id"), BAD_CAST(OString::number(GetSeqNo()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("author"), BAD_CAST(SW_MOD()->GetRedlineAuthor(GetAuthor()).toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("date"), BAD_CAST(DateTimeToOString(GetTimeStamp()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("descr"), BAD_CAST(const_cast<SwRangeRedline*>(this)->GetDescr().toUtf8().getStr()));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("id"), BAD_CAST(OString::number(GetSeqNo()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("author"), BAD_CAST(SW_MOD()->GetRedlineAuthor(GetAuthor()).toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("date"), BAD_CAST(DateTimeToOString(GetTimeStamp()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("descr"), BAD_CAST(const_cast<SwRangeRedline*>(this)->GetDescr().toUtf8().getStr()));
 
     OString sRedlineType;
     switch (GetType())
@@ -1924,11 +1924,11 @@ void SwRangeRedline::dumpAsXml(xmlTextWriterPtr pWriter) const
             sRedlineType = "UNKNOWN";
             break;
     }
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("type"), BAD_CAST(sRedlineType.getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("type"), BAD_CAST(sRedlineType.getStr()));
 
     SwPaM::dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void SwExtraRedlineTable::Insert( SwExtraRedline* p )
diff --git a/sw/source/core/doc/fmtcol.cxx b/sw/source/core/doc/fmtcol.cxx
index c82a96859beb..c31c406cd60a 100644
--- a/sw/source/core/doc/fmtcol.cxx
+++ b/sw/source/core/doc/fmtcol.cxx
@@ -471,18 +471,18 @@ bool SwTextFormatColl::AreListLevelIndentsApplicable() const
 
 void SwTextFormatColl::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextFormatColl"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextFormatColl"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
     GetAttrSet().dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void SwTextFormatColls::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextFormatColls"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextFormatColls"));
     for (size_t i = 0; i < size(); ++i)
         GetFormat(i)->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 //FEATURE::CONDCOLL
diff --git a/sw/source/core/doc/number.cxx b/sw/source/core/doc/number.cxx
index 4b2405830ad1..5149d222a3d2 100644
--- a/sw/source/core/doc/number.cxx
+++ b/sw/source/core/doc/number.cxx
@@ -1085,10 +1085,10 @@ void SwNumRule::RemoveParagraphStyle( SwTextFormatColl& rTextFormatColl )
 
 void SwNumRule::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwNumRule"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("msName"), BAD_CAST(msName.toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("mnPoolFormatId"), BAD_CAST(OString::number(mnPoolFormatId).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("mbAutoRuleFlag"), BAD_CAST(OString::boolean(mbAutoRuleFlag).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwNumRule"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("msName"), BAD_CAST(msName.toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("mnPoolFormatId"), BAD_CAST(OString::number(mnPoolFormatId).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("mbAutoRuleFlag"), BAD_CAST(OString::boolean(mbAutoRuleFlag).getStr()));
 
     for (const auto& pFormat : maFormats)
     {
@@ -1100,7 +1100,7 @@ void SwNumRule::dumpAsXml(xmlTextWriterPtr pWriter) const
         pFormat->dumpAsXml(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void SwNumRule::GetGrabBagItem(uno::Any& rVal) const
@@ -1529,10 +1529,10 @@ namespace numfunc
 
 void SwNumRuleTable::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwNumRuleTable"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwNumRuleTable"));
     for (SwNumRule* pNumRule : *this)
         pNumRule->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/docnode/node.cxx b/sw/source/core/docnode/node.cxx
index 7f9bae8a01f2..809ecd349c81 100644
--- a/sw/source/core/docnode/node.cxx
+++ b/sw/source/core/docnode/node.cxx
@@ -898,11 +898,11 @@ void SwNode::dumpAsXml(xmlTextWriterPtr pWriter) const
         break;
     default: break;
     }
-    xmlTextWriterStartElement(pWriter, BAD_CAST(pName));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST(pName));
 
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("type"), BAD_CAST(OString::number(static_cast<sal_uInt8>(GetNodeType())).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"), BAD_CAST(OString::number(GetIndex()).getStr()));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("type"), BAD_CAST(OString::number(static_cast<sal_uInt8>(GetNodeType())).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"), BAD_CAST(OString::number(GetIndex()).getStr()));
 
     switch (GetNodeType())
     {
@@ -912,28 +912,28 @@ void SwNode::dumpAsXml(xmlTextWriterPtr pWriter) const
             const tools::PolyPolygon* pContour = pNoTextNode->HasContour();
             if (pContour)
             {
-                xmlTextWriterStartElement(pWriter, BAD_CAST("pContour"));
+                (void)xmlTextWriterStartElement(pWriter, BAD_CAST("pContour"));
                 for (sal_uInt16 i = 0; i < pContour->Count(); ++i)
                 {
-                    xmlTextWriterStartElement(pWriter, BAD_CAST("polygon"));
-                    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
+                    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("polygon"));
+                    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
                                                 BAD_CAST(OString::number(i).getStr()));
                     const tools::Polygon& rPolygon = pContour->GetObject(i);
                     for (sal_uInt16 j = 0; j < rPolygon.GetSize(); ++j)
                     {
-                        xmlTextWriterStartElement(pWriter, BAD_CAST("point"));
-                        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
+                        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("point"));
+                        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
                                                     BAD_CAST(OString::number(j).getStr()));
                         const Point& rPoint = rPolygon.GetPoint(j);
-                        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("x"),
+                        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("x"),
                                                     BAD_CAST(OString::number(rPoint.X()).getStr()));
-                        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("y"),
+                        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("y"),
                                                     BAD_CAST(OString::number(rPoint.Y()).getStr()));
-                        xmlTextWriterEndElement(pWriter);
+                        (void)xmlTextWriterEndElement(pWriter);
                     }
-                    xmlTextWriterEndElement(pWriter);
+                    (void)xmlTextWriterEndElement(pWriter);
                 }
-                xmlTextWriterEndElement(pWriter);
+                (void)xmlTextWriterEndElement(pWriter);
             }
         }
         break;
@@ -941,9 +941,9 @@ void SwNode::dumpAsXml(xmlTextWriterPtr pWriter) const
             break;
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
     if (GetNodeType() == SwNodeType::End)
-        xmlTextWriterEndElement(pWriter); // end start node
+        (void)xmlTextWriterEndElement(pWriter); // end start node
 }
 
 SwStartNode::SwStartNode( const SwNodeIndex &rWhere, const SwNodeType nNdType,
@@ -1020,28 +1020,28 @@ void SwStartNode::dumpAsXml(xmlTextWriterPtr pWriter) const
         break;
     }
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST(pName));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("type"), BAD_CAST(OString::number(static_cast<sal_uInt8>(GetNodeType())).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"), BAD_CAST(OString::number(GetIndex()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST(pName));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("type"), BAD_CAST(OString::number(static_cast<sal_uInt8>(GetNodeType())).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"), BAD_CAST(OString::number(GetIndex()).getStr()));
 
     if (IsTableNode())
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("attrset"));
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("attrset"));
         GetTableNode()->GetTable().GetFrameFormat()->GetAttrSet().dumpAsXml(pWriter);
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
     else if (GetStartNodeType() == SwTableBoxStartNode)
     {
         if (SwTableBox* pBox = GetTableBox())
-            xmlTextWriterWriteAttribute(pWriter, BAD_CAST("rowspan"), BAD_CAST(OString::number(pBox->getRowSpan()).getStr()));
-        xmlTextWriterStartElement(pWriter, BAD_CAST("attrset"));
+            (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("rowspan"), BAD_CAST(OString::number(pBox->getRowSpan()).getStr()));
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("attrset"));
         if (SwTableBox* pBox = GetTableBox())
             pBox->GetFrameFormat()->GetAttrSet().dumpAsXml(pWriter);
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
 
-    // xmlTextWriterEndElement(pWriter); - it is a start node, so don't end, will make xml better nested
+    // (void)xmlTextWriterEndElement(pWriter); - it is a start node, so don't end, will make xml better nested
 }
 
 
diff --git a/sw/source/core/docnode/nodes.cxx b/sw/source/core/docnode/nodes.cxx
index 827604a9cfc4..da593261074b 100644
--- a/sw/source/core/docnode/nodes.cxx
+++ b/sw/source/core/docnode/nodes.cxx
@@ -2333,10 +2333,10 @@ bool SwNodes::IsDocNodes() const
 
 void SwNodes::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwNodes"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwNodes"));
     for (sal_uLong i = 0; i < Count(); ++i)
         (*this)[i]->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/docnode/section.cxx b/sw/source/core/docnode/section.cxx
index 41b894b4afad..c65afd1e5749 100644
--- a/sw/source/core/docnode/section.cxx
+++ b/sw/source/core/docnode/section.cxx
@@ -1025,18 +1025,18 @@ bool SwSectionFormat::supportsFullDrawingLayerFillAttributeSet() const
 
 void SwSectionFormat::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwSectionFormat"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwSectionFormat"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
     GetAttrSet().dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void SwSectionFormats::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwSectionFormats"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwSectionFormats"));
     for (size_t i = 0; i < size(); ++i)
         GetFormat(i)->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // Method to break section links inside a linked section
diff --git a/sw/source/core/fields/authfld.cxx b/sw/source/core/fields/authfld.cxx
index 8812d70d2db6..f57603509fd2 100644
--- a/sw/source/core/fields/authfld.cxx
+++ b/sw/source/core/fields/authfld.cxx
@@ -612,26 +612,26 @@ bool SwAuthorityField::HasURL() const
 
 void SwAuthorityField::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwAuthorityField"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwAuthorityField"));
     SwField::dumpAsXml(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_xAuthEntry"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", m_xAuthEntry.get());
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_xAuthEntry"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", m_xAuthEntry.get());
     if (m_xAuthEntry.is())
     {
         m_xAuthEntry->dumpAsXml(pWriter);
     }
-    xmlTextWriterEndElement(pWriter);
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_nTempSequencePos"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_nTempSequencePos"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::number(m_nTempSequencePos).getStr()));
-    xmlTextWriterEndElement(pWriter);
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_nTempSequencePosRLHidden"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_nTempSequencePosRLHidden"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::number(m_nTempSequencePosRLHidden).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 const char* const aFieldNames[] =
@@ -671,17 +671,17 @@ const char* const aFieldNames[] =
 
 void SwAuthEntry::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwAuthEntry"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwAuthEntry"));
 
     for (int i = 0; i < AUTH_FIELD_END; ++i)
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("m_aAuthField"));
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("key"), BAD_CAST(aFieldNames[i]));
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(m_aAuthFields[i].toUtf8().getStr()));
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_aAuthField"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("key"), BAD_CAST(aFieldNames[i]));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(m_aAuthFields[i].toUtf8().getStr()));
+        (void)xmlTextWriterEndElement(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 bool    SwAuthorityField::QueryValue( Any& rAny, sal_uInt16 /*nWhichId*/ ) const
diff --git a/sw/source/core/fields/docufld.cxx b/sw/source/core/fields/docufld.cxx
index 9297cebb11be..388140e0a2d8 100644
--- a/sw/source/core/fields/docufld.cxx
+++ b/sw/source/core/fields/docufld.cxx
@@ -1931,18 +1931,18 @@ bool SwPostItField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
 
 void SwPostItField::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwPostItField"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwPostItField"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
 
     SwField::dumpAsXml(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("mpText"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", mpText.get());
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("mpText"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", mpText.get());
     if (mpText)
         mpText->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // extended user information field type
diff --git a/sw/source/core/fields/fldbas.cxx b/sw/source/core/fields/fldbas.cxx
index b942dd47726c..2d824ac52c28 100644
--- a/sw/source/core/fields/fldbas.cxx
+++ b/sw/source/core/fields/fldbas.cxx
@@ -162,10 +162,10 @@ void SwFieldType::dumpAsXml(xmlTextWriterPtr pWriter) const
     GatherFields(vFields);
     if(!vFields.size())
         return;
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFieldType"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFieldType"));
     for(const auto pFormatField: vFields)
         pFormatField->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SwFormatField* SwFieldType::FindFormatForField(const SwField* pField) const {
@@ -209,11 +209,11 @@ void SwFieldType::GatherFields(std::vector<SwFormatField*>& rvFields, bool bColl
 
 void SwFieldTypes::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFieldTypes"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFieldTypes"));
     sal_uInt16 nCount = size();
     for (sal_uInt16 nType = 0; nType < nCount; ++nType)
         (*this)[nType]->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // Base class for all fields.
@@ -672,10 +672,10 @@ sal_uInt32 SwValueField::GetSystemFormat(SvNumberFormatter* pFormatter, sal_uInt
 
 void SwValueField::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwValueField"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_fValue"), BAD_CAST(OString::number(m_fValue).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwValueField"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_fValue"), BAD_CAST(OString::number(m_fValue).getStr()));
     SwField::dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /// set language of the format
@@ -831,13 +831,13 @@ bool SwField::IsClickable() const
 
 void SwField::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwField"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s", BAD_CAST(typeid(*this).name()));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nFormat"), BAD_CAST(OString::number(m_nFormat).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nLang"), BAD_CAST(OString::number(m_nLang.get()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwField"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s", BAD_CAST(typeid(*this).name()));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nFormat"), BAD_CAST(OString::number(m_nFormat).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nLang"), BAD_CAST(OString::number(m_nLang.get()).getStr()));
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/fields/usrfld.cxx b/sw/source/core/fields/usrfld.cxx
index 0cff28fd7ba7..9feb828a156b 100644
--- a/sw/source/core/fields/usrfld.cxx
+++ b/sw/source/core/fields/usrfld.cxx
@@ -166,10 +166,10 @@ bool SwUserField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
 
 void SwUserField::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwUserField"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nSubType"), BAD_CAST(OString::number(m_nSubType).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwUserField"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nSubType"), BAD_CAST(OString::number(m_nSubType).getStr()));
     SwValueField::dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SwUserFieldType::SwUserFieldType( SwDoc* pDocPtr, const OUString& aNam )
@@ -369,12 +369,12 @@ void SwUserFieldType::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
 
 void SwUserFieldType::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwUserFieldType"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nValue"), BAD_CAST(OString::number(m_nValue).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aContent"), BAD_CAST(m_aContent.toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aContentLang"), BAD_CAST(m_aContentLang.toUtf8().getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwUserFieldType"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nValue"), BAD_CAST(OString::number(m_nValue).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aContent"), BAD_CAST(m_aContent.toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aContentLang"), BAD_CAST(m_aContentLang.toUtf8().getStr()));
     SwFieldType::dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/layout/atrfrm.cxx b/sw/source/core/layout/atrfrm.cxx
index cab6e41b341f..2fdf0f9ba0c2 100644
--- a/sw/source/core/layout/atrfrm.cxx
+++ b/sw/source/core/layout/atrfrm.cxx
@@ -445,21 +445,21 @@ bool SwFormatFrameSize::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 
 void SwFormatFrameSize::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatFrameSize"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatFrameSize"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
 
     std::stringstream aSize;
     aSize << GetSize();
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(aSize.str().c_str()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(aSize.str().c_str()));
 
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eFrameHeightType"), BAD_CAST(OString::number(static_cast<int>(m_eFrameHeightType)).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eFrameWidthType"), BAD_CAST(OString::number(static_cast<int>(m_eFrameWidthType)).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidthPercent"), BAD_CAST(OString::number(m_nWidthPercent).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eWidthPercentRelation"), BAD_CAST(OString::number(m_eWidthPercentRelation).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nHeightPercent"), BAD_CAST(OString::number(m_nHeightPercent).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eHeightPercentRelation"), BAD_CAST(OString::number(m_eHeightPercentRelation).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eFrameHeightType"), BAD_CAST(OString::number(static_cast<int>(m_eFrameHeightType)).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eFrameWidthType"), BAD_CAST(OString::number(static_cast<int>(m_eFrameWidthType)).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidthPercent"), BAD_CAST(OString::number(m_nWidthPercent).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eWidthPercentRelation"), BAD_CAST(OString::number(m_eWidthPercentRelation).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nHeightPercent"), BAD_CAST(OString::number(m_nHeightPercent).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eHeightPercentRelation"), BAD_CAST(OString::number(m_eHeightPercentRelation).getStr()));
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // Partially implemented inline in hxx
@@ -607,17 +607,17 @@ SwFormatContent* SwFormatContent::Clone( SfxItemPool* ) const
 
 void SwFormatContent::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatContent"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatContent"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
     if (m_pStartNode)
     {
-        xmlTextWriterWriteAttribute(
+        (void)xmlTextWriterWriteAttribute(
             pWriter, BAD_CAST("startNode"),
             BAD_CAST(OString::number(m_pStartNode->GetNode().GetIndex()).getStr()));
-        xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("startNodePtr"), "%p",
+        (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("startNodePtr"), "%p",
                                           &m_pStartNode->GetNode());
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // Partially implemented inline in hxx
@@ -784,16 +784,16 @@ bool SwFormatPageDesc::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 
 void SwFormatPageDesc::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatPageDesc"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatPageDesc"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
     if (m_oNumOffset)
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("oNumOffset"), BAD_CAST(OString::number(*m_oNumOffset).getStr()));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("oNumOffset"), BAD_CAST(OString::number(*m_oNumOffset).getStr()));
     else
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("oNumOffset"), BAD_CAST("none"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("pPageDesc"), "%p", GetPageDesc());
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("oNumOffset"), BAD_CAST("none"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("pPageDesc"), "%p", GetPageDesc());
     if (const SwPageDesc* pPageDesc = GetPageDesc())
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(pPageDesc->GetName().toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(pPageDesc->GetName().toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 //  class SwFormatCol
@@ -815,13 +815,13 @@ bool SwColumn::operator==( const SwColumn &rCmp ) const
 
 void SwColumn::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwColumn"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWish"), BAD_CAST(OString::number(m_nWish).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nUpper"), BAD_CAST(OString::number(0).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLower"), BAD_CAST(OString::number(0).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLeft"), BAD_CAST(OString::number(m_nLeft).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nRight"), BAD_CAST(OString::number(m_nRight).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwColumn"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWish"), BAD_CAST(OString::number(m_nWish).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nUpper"), BAD_CAST(OString::number(0).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLower"), BAD_CAST(OString::number(0).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLeft"), BAD_CAST(OString::number(m_nLeft).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nRight"), BAD_CAST(OString::number(m_nRight).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SwFormatCol::SwFormatCol( const SwFormatCol& rCpy )
@@ -1148,23 +1148,23 @@ bool SwFormatCol::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 
 void SwFormatCol::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatCol"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eLineStyle"), BAD_CAST(OString::number(static_cast<sal_Int16>(m_eLineStyle)).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLineWidth"), BAD_CAST(OString::number(m_nLineWidth).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aLineColor"), BAD_CAST(m_aLineColor.AsRGBHexString().toUtf8().getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLineHeight"), BAD_CAST(OString::number(m_nLineHeight).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eAdj"), BAD_CAST(OString::number(m_eAdj).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidth"), BAD_CAST(OString::number(m_nWidth).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidthAdjustValue"), BAD_CAST(OString::number(m_aWidthAdjustValue).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bOrtho"), BAD_CAST(OString::boolean(m_bOrtho).getStr()));
-
-    xmlTextWriterStartElement(pWriter, BAD_CAST("aColumns"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatCol"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eLineStyle"), BAD_CAST(OString::number(static_cast<sal_Int16>(m_eLineStyle)).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLineWidth"), BAD_CAST(OString::number(m_nLineWidth).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aLineColor"), BAD_CAST(m_aLineColor.AsRGBHexString().toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLineHeight"), BAD_CAST(OString::number(m_nLineHeight).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eAdj"), BAD_CAST(OString::number(m_eAdj).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidth"), BAD_CAST(OString::number(m_nWidth).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidthAdjustValue"), BAD_CAST(OString::number(m_aWidthAdjustValue).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bOrtho"), BAD_CAST(OString::boolean(m_bOrtho).getStr()));
+
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("aColumns"));
     for (const SwColumn& rColumn : m_aColumns)
         rColumn.dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // Partially implemented inline in hxx
@@ -1256,20 +1256,20 @@ bool SwFormatSurround::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 
 void SwFormatSurround::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatSurround"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(static_cast<sal_Int32>(GetValue())).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatSurround"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(static_cast<sal_Int32>(GetValue())).getStr()));
 
     OUString aPresentation;
     IntlWrapper aIntlWrapper(SvtSysLocale().GetUILanguageTag());
     GetPresentation(SfxItemPresentation::Nameless, MapUnit::Map100thMM, MapUnit::Map100thMM, aPresentation, aIntlWrapper);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(aPresentation.toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(aPresentation.toUtf8().getStr()));
 
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bAnchorOnly"), BAD_CAST(OString::boolean(m_bAnchorOnly).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bContour"), BAD_CAST(OString::boolean(m_bContour).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bOutside"), BAD_CAST(OString::boolean(m_bOutside).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bAnchorOnly"), BAD_CAST(OString::boolean(m_bAnchorOnly).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bContour"), BAD_CAST(OString::boolean(m_bContour).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bOutside"), BAD_CAST(OString::boolean(m_bOutside).getStr()));
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // Partially implemented inline in hxx
@@ -1356,12 +1356,12 @@ bool SwFormatVertOrient::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 
 void SwFormatVertOrient::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatVertOrient"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nYPos"), BAD_CAST(OString::number(m_nYPos).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eOrient"), BAD_CAST(OString::number(m_eOrient).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eRelation"), BAD_CAST(OString::number(m_eRelation).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatVertOrient"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nYPos"), BAD_CAST(OString::number(m_nYPos).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eOrient"), BAD_CAST(OString::number(m_eOrient).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eRelation"), BAD_CAST(OString::number(m_eRelation).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // Partially implemented inline in hxx
@@ -1457,13 +1457,13 @@ bool SwFormatHoriOrient::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 
 void SwFormatHoriOrient::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatHoriOrient"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nXPos"), BAD_CAST(OString::number(m_nXPos).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eOrient"), BAD_CAST(OString::number(m_eOrient).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eRelation"), BAD_CAST(OString::number(m_eRelation).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bPosToggle"), BAD_CAST(OString::boolean(m_bPosToggle).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatHoriOrient"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nXPos"), BAD_CAST(OString::number(m_nXPos).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eOrient"), BAD_CAST(OString::number(m_eOrient).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eRelation"), BAD_CAST(OString::number(m_eRelation).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bPosToggle"), BAD_CAST(OString::boolean(m_bPosToggle).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // Partially implemented inline in hxx
@@ -1672,27 +1672,27 @@ bool SwFormatAnchor::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
 
 void SwFormatAnchor::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatAnchor"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatAnchor"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
 
     if (m_pContentAnchor)
     {
         std::stringstream aContentAnchor;
         aContentAnchor << *m_pContentAnchor;
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_pContentAnchor"), BAD_CAST(aContentAnchor.str().c_str()));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_pContentAnchor"), BAD_CAST(aContentAnchor.str().c_str()));
     }
     else
-        xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("m_pContentAnchor"), "%p", m_pContentAnchor.get());
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_eAnchorType"), BAD_CAST(OString::number(static_cast<int>(m_eAnchorId)).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nPageNumber"), BAD_CAST(OString::number(m_nPageNumber).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nOrder"), BAD_CAST(OString::number(m_nOrder).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("s_nOrderCounter"), BAD_CAST(OString::number(s_nOrderCounter).getStr()));
+        (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("m_pContentAnchor"), "%p", m_pContentAnchor.get());
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_eAnchorType"), BAD_CAST(OString::number(static_cast<int>(m_eAnchorId)).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nPageNumber"), BAD_CAST(OString::number(m_nPageNumber).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nOrder"), BAD_CAST(OString::number(m_nOrder).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("s_nOrderCounter"), BAD_CAST(OString::number(s_nOrderCounter).getStr()));
     OUString aPresentation;
     IntlWrapper aIntlWrapper(SvtSysLocale().GetUILanguageTag());
     GetPresentation(SfxItemPresentation::Nameless, MapUnit::Map100thMM, MapUnit::Map100thMM, aPresentation, aIntlWrapper);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(aPresentation.toUtf8().getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(aPresentation.toUtf8().getStr()));
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // Partially implemented inline in hxx
@@ -1868,10 +1868,10 @@ SwFormatNoBalancedColumns* SwFormatNoBalancedColumns::Clone( SfxItemPool* ) cons
 
 void SwFormatNoBalancedColumns::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatNoBalancedColumns"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatNoBalancedColumns"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // class SwFormatFootnoteEndAtTextEnd
@@ -2804,10 +2804,10 @@ OUString SwFrameFormat::GetDescription() const
 
 void SwFrameFormat::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFrameFormat"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFrameFormat"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
 
     const char* pWhich = nullptr;
     switch (Which())
@@ -2820,11 +2820,11 @@ void SwFrameFormat::dumpAsXml(xmlTextWriterPtr pWriter) const
         break;
     }
     if (pWhich)
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("which"), BAD_CAST(pWhich));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("which"), BAD_CAST(pWhich));
 
     if (m_pOtherTextBoxFormat)
     {
-        xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("OtherTextBoxFormat"), "%p", m_pOtherTextBoxFormat);
+        (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("OtherTextBoxFormat"), "%p", m_pOtherTextBoxFormat);
     }
 
     GetAttrSet().dumpAsXml(pWriter);
@@ -2832,15 +2832,15 @@ void SwFrameFormat::dumpAsXml(xmlTextWriterPtr pWriter) const
     if (const SdrObject* pSdrObject = FindSdrObject())
         pSdrObject->dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void SwFrameFormats::dumpAsXml(xmlTextWriterPtr pWriter, const char* pName) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST(pName));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST(pName));
     for (const SwFrameFormat *pFormat : m_PosIndex)
         pFormat->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 
diff --git a/sw/source/core/layout/dumpfilter.cxx b/sw/source/core/layout/dumpfilter.cxx
index 2ba71faf74d9..073d6a7e69b5 100644
--- a/sw/source/core/layout/dumpfilter.cxx
+++ b/sw/source/core/layout/dumpfilter.cxx
@@ -106,12 +106,12 @@ namespace sw
 
             xmlTextWriterPtr writer = xmlNewTextWriter( outBuffer );
             xmlTextWriterSetIndent(writer, 1);
-            xmlTextWriterStartDocument( writer, nullptr, nullptr, nullptr );
+            (void)xmlTextWriterStartDocument( writer, nullptr, nullptr, nullptr );
 
             // TODO This doesn't export the whole XML file, whereas dumpAsXML() does it nicely
             pLayout->dumpAsXml( writer );
 
-            xmlTextWriterEndDocument( writer );
+            (void)xmlTextWriterEndDocument( writer );
             xmlFreeTextWriter( writer );
 
             bRet = true;
diff --git a/sw/source/core/layout/pagedesc.cxx b/sw/source/core/layout/pagedesc.cxx
index 7013bf87aede..8b8b5282abbf 100644
--- a/sw/source/core/layout/pagedesc.cxx
+++ b/sw/source/core/layout/pagedesc.cxx
@@ -512,32 +512,32 @@ SwPageDesc* SwPageDesc::GetByName(SwDoc& rDoc, std::u16string_view rName)
 
 void SwPageDesc::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwPageDesc"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("m_StyleName"), "%s",
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwPageDesc"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("m_StyleName"), "%s",
                                       BAD_CAST(m_StyleName.toUtf8().getStr()));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("m_pFollow"), "%p", m_pFollow);
-    xmlTextWriterWriteFormatAttribute(
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("m_pFollow"), "%p", m_pFollow);
+    (void)xmlTextWriterWriteFormatAttribute(
         pWriter, BAD_CAST("m_eUse"), "0x%s",
         BAD_CAST(OString::number(static_cast<int>(m_eUse), 16).getStr()));
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_Master"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_Master"));
     m_Master.dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_Left"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_Left"));
     m_Left.dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_FirstMaster"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_FirstMaster"));
     m_FirstMaster.dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_FirstLeft"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_FirstLeft"));
     m_FirstLeft.dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SwPageFootnoteInfo::SwPageFootnoteInfo()
@@ -704,14 +704,14 @@ void SwPageDescs::erase( size_type index_ )
 
 void SwPageDescs::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwPageDescs"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwPageDescs"));
 
     for (const auto& pPageDesc : m_PosIndex)
     {
         pPageDesc->dumpAsXml(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/layout/tabfrm.cxx b/sw/source/core/layout/tabfrm.cxx
index 25b69f680b58..bbfaf327c96c 100644
--- a/sw/source/core/layout/tabfrm.cxx
+++ b/sw/source/core/layout/tabfrm.cxx
@@ -5585,10 +5585,10 @@ void SwCellFrame::dumpAsXmlAttributes(xmlTextWriterPtr pWriter) const
 {
     SwFrame::dumpAsXmlAttributes(pWriter);
     if (SwCellFrame* pFollow = GetFollowCell())
-        xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("follow"), "%" SAL_PRIuUINT32, pFollow->GetFrameId());
+        (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("follow"), "%" SAL_PRIuUINT32, pFollow->GetFrameId());
 
     if (SwCellFrame* pPrevious = GetPreviousCell())
-        xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("precede"), "%" SAL_PRIuUINT32, pPrevious->GetFrameId());
+        (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("precede"), "%" SAL_PRIuUINT32, pPrevious->GetFrameId());
 }
 
 // #i103961#
diff --git a/sw/source/core/ole/ndole.cxx b/sw/source/core/ole/ndole.cxx
index b098b089c1d2..69756da640e5 100644
--- a/sw/source/core/ole/ndole.cxx
+++ b/sw/source/core/ole/ndole.cxx
@@ -292,14 +292,14 @@ bool SwOLENode::RestorePersistentData()
 
 void SwOLENode::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwOLENode"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwOLENode"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
                                 BAD_CAST(OString::number(GetIndex()).getStr()));
 
     GetOLEObj().dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /**
@@ -1135,11 +1135,11 @@ void SwOLEObj::resetBufferedData()
 
 void SwOLEObj::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwOLEObj"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwOLEObj"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_xOLERef"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("symbol"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_xOLERef"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("symbol"),
                                 BAD_CAST(typeid(*m_xOLERef.GetObject()).name()));
 
     uno::Reference<embed::XEmbeddedObject> xIP = m_xOLERef.GetObject();
@@ -1149,9 +1149,9 @@ void SwOLEObj::dumpAsXml(xmlTextWriterPtr pWriter) const
         pComponent->dumpAsXml(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SwOLELRUCache::SwOLELRUCache()
diff --git a/sw/source/core/para/paratr.cxx b/sw/source/core/para/paratr.cxx
index ede55b9e92a3..b8c6e668b01a 100644
--- a/sw/source/core/para/paratr.cxx
+++ b/sw/source/core/para/paratr.cxx
@@ -207,10 +207,10 @@ bool    SwNumRuleItem::PutValue( const uno::Any& rVal, sal_uInt8 )
 
 void SwNumRuleItem::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwNumRuleItem"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(GetValue().toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwNumRuleItem"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(GetValue().toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SwParaConnectBorderItem* SwParaConnectBorderItem::Clone( SfxItemPool * ) const
diff --git a/sw/source/core/text/xmldump.cxx b/sw/source/core/text/xmldump.cxx
index 03729d6156b0..8ad6d956aba4 100644
--- a/sw/source/core/text/xmldump.cxx
+++ b/sw/source/core/text/xmldump.cxx
@@ -127,22 +127,22 @@ class XmlPortionDumper:public SwPortionHandler
                        sal_Int32 nHeight,
                        sal_Int32 nWidth) override
     {
-        xmlTextWriterStartElement( writer, BAD_CAST( "Text" ) );
-        xmlTextWriterWriteFormatAttribute( writer,
+        (void)xmlTextWriterStartElement( writer, BAD_CAST( "Text" ) );
+        (void)xmlTextWriterWriteFormatAttribute( writer,
                                            BAD_CAST( "nLength" ),
                                            "%i", static_cast<int>(static_cast<sal_Int32>(nLength)) );
-        xmlTextWriterWriteFormatAttribute( writer,
+        (void)xmlTextWriterWriteFormatAttribute( writer,
                                            BAD_CAST( "nType" ),
                                            "%s", getTypeName( nType ) );
         if (nHeight > 0)
-            xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("nHeight"), "%i", static_cast<int>(nHeight));
+            (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("nHeight"), "%i", static_cast<int>(nHeight));
         if (nWidth > 0)
-            xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("nWidth"), "%i", static_cast<int>(nWidth));
+            (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("nWidth"), "%i", static_cast<int>(nWidth));
         if (nLength > TextFrameIndex(0))
-            xmlTextWriterWriteAttribute(writer, BAD_CAST("Portion"),
+            (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("Portion"),
                 BAD_CAST(m_rText.copy(sal_Int32(ofs), sal_Int32(nLength)).toUtf8().getStr()));
 
-        xmlTextWriterEndElement( writer );
+        (void)xmlTextWriterEndElement( writer );
         m_aLine += m_rText.subView(sal_Int32(ofs), sal_Int32(nLength));
         ofs += nLength;
     }
@@ -164,45 +164,45 @@ class XmlPortionDumper:public SwPortionHandler
                           sal_Int32 nWidth,
                           const SwFont* pFont ) override
     {
-        xmlTextWriterStartElement( writer, BAD_CAST( "Special" ) );
-        xmlTextWriterWriteFormatAttribute( writer,
+        (void)xmlTextWriterStartElement( writer, BAD_CAST( "Special" ) );
+        (void)xmlTextWriterWriteFormatAttribute( writer,
                                            BAD_CAST( "nLength" ),
                                            "%i", static_cast<int>(static_cast<sal_Int32>(nLength)) );
-        xmlTextWriterWriteFormatAttribute( writer,
+        (void)xmlTextWriterWriteFormatAttribute( writer,
                                            BAD_CAST( "nType" ),
                                            "%s", getTypeName( nType ) );
         OString sText8 = OUStringToOString( rText, RTL_TEXTENCODING_UTF8 );
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "rText" ),
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "rText" ),
                                            "%s", sText8.getStr(  ) );
 
         if (nHeight > 0)
-            xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("nHeight"), "%i", static_cast<int>(nHeight));
+            (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("nHeight"), "%i", static_cast<int>(nHeight));
 
         if (nWidth > 0)
-            xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("nWidth"), "%i", static_cast<int>(nWidth));
+            (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("nWidth"), "%i", static_cast<int>(nWidth));
 
         if (pFont)
             pFont->dumpAsXml(writer);
 
-        xmlTextWriterEndElement( writer );
+        (void)xmlTextWriterEndElement( writer );
         m_aLine += rText;
         ofs += nLength;
     }
 
     virtual void LineBreak( sal_Int32 nWidth ) override
     {
-        xmlTextWriterStartElement( writer, BAD_CAST( "LineBreak" ) );
+        (void)xmlTextWriterStartElement( writer, BAD_CAST( "LineBreak" ) );
         if (nWidth > 0)
-            xmlTextWriterWriteFormatAttribute( writer,
+            (void)xmlTextWriterWriteFormatAttribute( writer,
                                                BAD_CAST( "nWidth" ),
                                                "%i", static_cast<int>(nWidth) );
         if (!m_aLine.isEmpty())
         {
-            xmlTextWriterWriteAttribute(writer, BAD_CAST("Line"),
+            (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("Line"),
                                         BAD_CAST(m_aLine.toUtf8().getStr()));
             m_aLine.clear();
         }
-        xmlTextWriterEndElement( writer );
+        (void)xmlTextWriterEndElement( writer );
     }
 
     /**
@@ -211,18 +211,18 @@ class XmlPortionDumper:public SwPortionHandler
       */
     virtual void Skip( TextFrameIndex nLength ) override
     {
-        xmlTextWriterStartElement( writer, BAD_CAST( "Skip" ) );
-        xmlTextWriterWriteFormatAttribute( writer,
+        (void)xmlTextWriterStartElement( writer, BAD_CAST( "Skip" ) );
+        (void)xmlTextWriterWriteFormatAttribute( writer,
                                            BAD_CAST( "nLength" ),
                                            "%i", static_cast<int>(static_cast<sal_Int32>(nLength)) );
-        xmlTextWriterEndElement( writer );
+        (void)xmlTextWriterEndElement( writer );
         ofs += nLength;
     }
 
     virtual void Finish(  ) override
     {
-        xmlTextWriterStartElement( writer, BAD_CAST( "Finish" ) );
-        xmlTextWriterEndElement( writer );
+        (void)xmlTextWriterStartElement( writer, BAD_CAST( "Finish" ) );
+        (void)xmlTextWriterEndElement( writer );
     }
 
 };
@@ -232,13 +232,13 @@ class XmlPortionDumper:public SwPortionHandler
         xmlTextWriterPtr writer = xmlNewTextWriterFilename( "layout.xml", 0 );
         xmlTextWriterSetIndent(writer,1);
         xmlTextWriterSetIndentString(writer, BAD_CAST("  "));
-        xmlTextWriterStartDocument( writer, nullptr, nullptr, nullptr );
+        (void)xmlTextWriterStartDocument( writer, nullptr, nullptr, nullptr );
         return writer;
     }
 
     void lcl_freeWriter( xmlTextWriterPtr writer )
     {
-        xmlTextWriterEndDocument( writer );
+        (void)xmlTextWriterEndDocument( writer );
         xmlFreeTextWriter( writer );
     }
 }
@@ -314,14 +314,14 @@ void SwFrame::dumpAsXml( xmlTextWriterPtr writer ) const
 
     if ( name != nullptr )
     {
-        xmlTextWriterStartElement( writer, reinterpret_cast<const xmlChar *>(name) );
+        (void)xmlTextWriterStartElement( writer, reinterpret_cast<const xmlChar *>(name) );
 
         dumpAsXmlAttributes( writer );
 
         if (IsRootFrame())
         {
             const SwRootFrame* pRootFrame = static_cast<const SwRootFrame*>(this);
-            xmlTextWriterStartElement(writer, BAD_CAST("sfxViewShells"));
+            (void)xmlTextWriterStartElement(writer, BAD_CAST("sfxViewShells"));
             SwView* pView = static_cast<SwView*>(SfxViewShell::GetFirst(true, checkSfxViewShell<SwView>));
             while (pView)
             {
@@ -329,25 +329,25 @@ void SwFrame::dumpAsXml( xmlTextWriterPtr writer ) const
                     pView->dumpAsXml(writer);
                 pView = static_cast<SwView*>(SfxViewShell::GetNext(*pView, true, checkSfxViewShell<SwView>));
             }
-            xmlTextWriterEndElement(writer);
+            (void)xmlTextWriterEndElement(writer);
         }
 
         if (IsPageFrame())
         {
             const SwPageFrame* pPageFrame = static_cast<const SwPageFrame*>(this);
-            xmlTextWriterStartElement(writer, BAD_CAST("page_status"));
-            xmlTextWriterWriteAttribute(writer, BAD_CAST("ValidFlyLayout"), BAD_CAST(OString::boolean(!pPageFrame->IsInvalidFlyLayout()).getStr()));
-            xmlTextWriterWriteAttribute(writer, BAD_CAST("ValidFlyContent"), BAD_CAST(OString::boolean(!pPageFrame->IsInvalidFlyContent()).getStr()));
-            xmlTextWriterWriteAttribute(writer, BAD_CAST("ValidFlyInCnt"), BAD_CAST(OString::boolean(!pPageFrame->IsInvalidFlyInCnt()).getStr()));
-            xmlTextWriterWriteAttribute(writer, BAD_CAST("ValidLayout"), BAD_CAST(OString::boolean(!pPageFrame->IsInvalidLayout()).getStr()));
-            xmlTextWriterWriteAttribute(writer, BAD_CAST("ValidContent"), BAD_CAST(OString::boolean(!pPageFrame->IsInvalidContent()).getStr()));
-            xmlTextWriterEndElement(writer);
-            xmlTextWriterStartElement(writer, BAD_CAST("page_info"));
-            xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("phyNum"), "%d", pPageFrame->GetPhyPageNum());
-            xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("virtNum"), "%d", pPageFrame->GetVirtPageNum());
+            (void)xmlTextWriterStartElement(writer, BAD_CAST("page_status"));
+            (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("ValidFlyLayout"), BAD_CAST(OString::boolean(!pPageFrame->IsInvalidFlyLayout()).getStr()));
+            (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("ValidFlyContent"), BAD_CAST(OString::boolean(!pPageFrame->IsInvalidFlyContent()).getStr()));
+            (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("ValidFlyInCnt"), BAD_CAST(OString::boolean(!pPageFrame->IsInvalidFlyInCnt()).getStr()));
+            (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("ValidLayout"), BAD_CAST(OString::boolean(!pPageFrame->IsInvalidLayout()).getStr()));
+            (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("ValidContent"), BAD_CAST(OString::boolean(!pPageFrame->IsInvalidContent()).getStr()));
+            (void)xmlTextWriterEndElement(writer);
+            (void)xmlTextWriterStartElement(writer, BAD_CAST("page_info"));
+            (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("phyNum"), "%d", pPageFrame->GetPhyPageNum());
+            (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("virtNum"), "%d", pPageFrame->GetVirtPageNum());
             OUString aFormatName = pPageFrame->GetPageDesc()->GetName();
-            xmlTextWriterWriteFormatAttribute( writer, BAD_CAST("pageDesc"), "%s", BAD_CAST(OUStringToOString(aFormatName, RTL_TEXTENCODING_UTF8).getStr()));
-            xmlTextWriterEndElement(writer);
+            (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST("pageDesc"), "%s", BAD_CAST(OUStringToOString(aFormatName, RTL_TEXTENCODING_UTF8).getStr()));
+            (void)xmlTextWriterEndElement(writer);
         }
 
         if (IsTextFrame())
@@ -356,42 +356,42 @@ void SwFrame::dumpAsXml( xmlTextWriterPtr writer ) const
             sw::MergedPara const*const pMerged(pTextFrame->GetMergedPara());
             if (pMerged)
             {
-                xmlTextWriterStartElement( writer, BAD_CAST( "merged" ) );
-                xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "paraPropsNodeIndex" ), "%" SAL_PRIuUINTPTR, pMerged->pParaPropsNode->GetIndex() );
+                (void)xmlTextWriterStartElement( writer, BAD_CAST( "merged" ) );
+                (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "paraPropsNodeIndex" ), "%" SAL_PRIuUINTPTR, pMerged->pParaPropsNode->GetIndex() );
                 for (auto const& e : pMerged->extents)
                 {
-                    xmlTextWriterStartElement( writer, BAD_CAST( "extent" ) );
-                    xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "txtNodeIndex" ), "%" SAL_PRIuUINTPTR, e.pNode->GetIndex() );
-                    xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "start" ), "%" SAL_PRIdINT32, e.nStart );
-                    xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "end" ), "%" SAL_PRIdINT32, e.nEnd );
-                    xmlTextWriterEndElement( writer );
+                    (void)xmlTextWriterStartElement( writer, BAD_CAST( "extent" ) );
+                    (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "txtNodeIndex" ), "%" SAL_PRIuUINTPTR, e.pNode->GetIndex() );
+                    (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "start" ), "%" SAL_PRIdINT32, e.nStart );
+                    (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "end" ), "%" SAL_PRIdINT32, e.nEnd );
+                    (void)xmlTextWriterEndElement( writer );
                 }
-                xmlTextWriterEndElement( writer );
+                (void)xmlTextWriterEndElement( writer );
             }
         }
 
         if (IsCellFrame())
         {
             SwCellFrame const* pCellFrame(static_cast<SwCellFrame const*>(this));
-            xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "rowspan" ), "%ld", pCellFrame->GetLayoutRowSpan() );
+            (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "rowspan" ), "%ld", pCellFrame->GetLayoutRowSpan() );
         }
 
-        xmlTextWriterStartElement( writer, BAD_CAST( "infos" ) );
+        (void)xmlTextWriterStartElement( writer, BAD_CAST( "infos" ) );
         dumpInfosAsXml( writer );
-        xmlTextWriterEndElement( writer );
+        (void)xmlTextWriterEndElement( writer );
 
         // Dump Anchored objects if any
         const SwSortedObjs* pAnchored = GetDrawObjs();
         if ( pAnchored && pAnchored->size() > 0 )
         {
-            xmlTextWriterStartElement( writer, BAD_CAST( "anchored" ) );
+            (void)xmlTextWriterStartElement( writer, BAD_CAST( "anchored" ) );
 
             for (SwAnchoredObject* pObject : *pAnchored)
             {
                 pObject->dumpAsXml( writer );
             }
 
-            xmlTextWriterEndElement( writer );
+            (void)xmlTextWriterEndElement( writer );
         }
 
         // Dump the children
@@ -405,7 +405,7 @@ void SwFrame::dumpAsXml( xmlTextWriterPtr writer ) const
             }
             OString aText8 =OUStringToOString( aText,
                                                           RTL_TEXTENCODING_UTF8 );
-            xmlTextWriterWriteString( writer,
+            (void)xmlTextWriterWriteString( writer,
                                       reinterpret_cast<const xmlChar *>(aText8.getStr(  )) );
             XmlPortionDumper pdumper( writer, aText );
             pTextFrame->VisitPortions( pdumper );
@@ -415,7 +415,7 @@ void SwFrame::dumpAsXml( xmlTextWriterPtr writer ) const
         {
             dumpChildrenAsXml( writer );
         }
-        xmlTextWriterEndElement( writer );
+        (void)xmlTextWriterEndElement( writer );
     }
 
     if ( bCreateWriter )
@@ -425,18 +425,18 @@ void SwFrame::dumpAsXml( xmlTextWriterPtr writer ) const
 void SwFrame::dumpInfosAsXml( xmlTextWriterPtr writer ) const
 {
     // output the Frame
-    xmlTextWriterStartElement( writer, BAD_CAST( "bounds" ) );
+    (void)xmlTextWriterStartElement( writer, BAD_CAST( "bounds" ) );
     getFrameArea().dumpAsXmlAttributes(writer);
-    xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFixSize"), BAD_CAST(OString::boolean(HasFixSize()).getStr()));
-    xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFrameAreaPositionValid"), BAD_CAST(OString::boolean(isFrameAreaPositionValid()).getStr()));
-    xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFrameAreaSizeValid"), BAD_CAST(OString::boolean(isFrameAreaSizeValid()).getStr()));
-    xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFramePrintAreaValid"), BAD_CAST(OString::boolean(isFramePrintAreaValid()).getStr()));
-    xmlTextWriterEndElement( writer );
+    (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFixSize"), BAD_CAST(OString::boolean(HasFixSize()).getStr()));
+    (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFrameAreaPositionValid"), BAD_CAST(OString::boolean(isFrameAreaPositionValid()).getStr()));
+    (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFrameAreaSizeValid"), BAD_CAST(OString::boolean(isFrameAreaSizeValid()).getStr()));
+    (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFramePrintAreaValid"), BAD_CAST(OString::boolean(isFramePrintAreaValid()).getStr()));
+    (void)xmlTextWriterEndElement( writer );
 
     // output the print area
-    xmlTextWriterStartElement( writer, BAD_CAST( "prtBounds" ) );
+    (void)xmlTextWriterStartElement( writer, BAD_CAST( "prtBounds" ) );
     getFramePrintArea().dumpAsXmlAttributes(writer);
-    xmlTextWriterEndElement( writer );
+    (void)xmlTextWriterEndElement( writer );
 }
 
 // Hack: somehow conversion from "..." to va_list does
@@ -445,37 +445,37 @@ const char* const TMP_FORMAT = "%" SAL_PRIuUINTPTR;
 
 void SwFrame::dumpAsXmlAttributes( xmlTextWriterPtr writer ) const
 {
-    xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "ptr" ), "%p", this );
-    xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "id" ), "%" SAL_PRIuUINT32, GetFrameId() );
-    xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "symbol" ), "%s", BAD_CAST( typeid( *this ).name( ) ) );
+    (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "ptr" ), "%p", this );
+    (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "id" ), "%" SAL_PRIuUINT32, GetFrameId() );
+    (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "symbol" ), "%s", BAD_CAST( typeid( *this ).name( ) ) );
     if ( GetNext( ) )
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "next" ), "%" SAL_PRIuUINT32, GetNext()->GetFrameId() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "next" ), "%" SAL_PRIuUINT32, GetNext()->GetFrameId() );
     if ( GetPrev( ) )
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "prev" ), "%" SAL_PRIuUINT32, GetPrev()->GetFrameId() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "prev" ), "%" SAL_PRIuUINT32, GetPrev()->GetFrameId() );
     if ( GetUpper( ) )
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "upper" ), "%" SAL_PRIuUINT32, GetUpper()->GetFrameId() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "upper" ), "%" SAL_PRIuUINT32, GetUpper()->GetFrameId() );
     if ( GetLower( ) )
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "lower" ), "%" SAL_PRIuUINT32, GetLower()->GetFrameId() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "lower" ), "%" SAL_PRIuUINT32, GetLower()->GetFrameId() );
     if (IsFootnoteFrame())
     {
         SwFootnoteFrame const*const pFF(static_cast<SwFootnoteFrame const*>(this));
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST("ref"), "%" SAL_PRIuUINT32, pFF->GetRef()->GetFrameId() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST("ref"), "%" SAL_PRIuUINT32, pFF->GetRef()->GetFrameId() );
         if (pFF->GetMaster())
-            xmlTextWriterWriteFormatAttribute( writer, BAD_CAST("master"), "%" SAL_PRIuUINT32, pFF->GetMaster()->GetFrameId() );
+            (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST("master"), "%" SAL_PRIuUINT32, pFF->GetMaster()->GetFrameId() );
         if (pFF->GetFollow())
-            xmlTextWriterWriteFormatAttribute( writer, BAD_CAST("follow"), "%" SAL_PRIuUINT32, pFF->GetFollow()->GetFrameId() );
+            (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST("follow"), "%" SAL_PRIuUINT32, pFF->GetFollow()->GetFrameId() );
     }
     if (IsSctFrame())
     {
         SwSectionFrame const*const pFrame(static_cast<SwSectionFrame const*>(this));
         SwSectionNode const*const pNode(pFrame->GetSection() ? pFrame->GetSection()->GetFormat()->GetSectionNode() : nullptr);
-        xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("sectionNodeIndex"), TMP_FORMAT, pNode ? pNode->GetIndex() : -1);
+        (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("sectionNodeIndex"), TMP_FORMAT, pNode ? pNode->GetIndex() : -1);
     }
     if ( IsTextFrame(  ) )
     {
         const SwTextFrame *pTextFrame = static_cast<const SwTextFrame *>(this);
         const SwTextNode *pTextNode = pTextFrame->GetTextNodeFirst();
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "txtNodeIndex" ), TMP_FORMAT, pTextNode->GetIndex() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "txtNodeIndex" ), TMP_FORMAT, pTextNode->GetIndex() );
 
         OString aMode = "Horizontal";
         if (IsVertLRBT())
@@ -490,14 +490,14 @@ void SwFrame::dumpAsXmlAttributes( xmlTextWriterPtr writer ) const
         {
             aMode = "Vertical";
         }
-        xmlTextWriterWriteAttribute(writer, BAD_CAST("WritingMode"), BAD_CAST(aMode.getStr()));
+        (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("WritingMode"), BAD_CAST(aMode.getStr()));
     }
     if (IsHeaderFrame() || IsFooterFrame())
     {
         const SwHeadFootFrame *pHeadFootFrame = static_cast<const SwHeadFootFrame*>(this);
         OUString aFormatName = pHeadFootFrame->GetFormat()->GetName();
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "fmtName" ), "%s", BAD_CAST(OUStringToOString(aFormatName, RTL_TEXTENCODING_UTF8).getStr()));
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "fmtPtr" ), "%p", pHeadFootFrame->GetFormat());
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "fmtName" ), "%s", BAD_CAST(OUStringToOString(aFormatName, RTL_TEXTENCODING_UTF8).getStr()));
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "fmtPtr" ), "%p", pHeadFootFrame->GetFormat());
     }
 }
 
@@ -516,17 +516,17 @@ void SwAnchoredObject::dumpAsXml( xmlTextWriterPtr writer ) const
     if ( bCreateWriter )
         writer = lcl_createDefaultWriter();
 
-    xmlTextWriterStartElement( writer, BAD_CAST( getElementName() ) );
-    xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "ptr" ), "%p", this );
+    (void)xmlTextWriterStartElement( writer, BAD_CAST( getElementName() ) );
+    (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "ptr" ), "%p", this );
 
-    xmlTextWriterStartElement( writer, BAD_CAST( "bounds" ) );
+    (void)xmlTextWriterStartElement( writer, BAD_CAST( "bounds" ) );
     GetObjBoundRect().dumpAsXmlAttributes(writer);
-    xmlTextWriterEndElement( writer );
+    (void)xmlTextWriterEndElement( writer );
 
     if (const SdrObject* pObject = GetDrawObj())
         pObject->dumpAsXml(writer);
 
-    xmlTextWriterEndElement( writer );
+    (void)xmlTextWriterEndElement( writer );
 
     if ( bCreateWriter )
         lcl_freeWriter( writer );
@@ -534,41 +534,41 @@ void SwAnchoredObject::dumpAsXml( xmlTextWriterPtr writer ) const
 
 void SwFont::dumpAsXml(xmlTextWriterPtr writer) const
 {
-    xmlTextWriterStartElement(writer, BAD_CAST("SwFont"));
-    xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(writer, BAD_CAST("SwFont"));
+    (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("ptr"), "%p", this);
     // do not use Color::AsRGBHexString() as that omits the transparency
-    xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("color"), "%08" SAL_PRIxUINT32, sal_uInt32(GetColor()));
-    xmlTextWriterEndElement(writer);
+    (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("color"), "%08" SAL_PRIxUINT32, sal_uInt32(GetColor()));
+    (void)xmlTextWriterEndElement(writer);
 }
 
 void SwTextFrame::dumpAsXmlAttributes( xmlTextWriterPtr writer ) const
 {
     SwFrame::dumpAsXmlAttributes( writer );
     if ( HasFollow() )
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "follow" ), "%" SAL_PRIuUINT32, GetFollow()->GetFrameId() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "follow" ), "%" SAL_PRIuUINT32, GetFollow()->GetFrameId() );
 
     if (m_pPrecede != nullptr)
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "precede" ), "%" SAL_PRIuUINT32, static_cast<SwTextFrame*>(m_pPrecede)->GetFrameId() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "precede" ), "%" SAL_PRIuUINT32, static_cast<SwTextFrame*>(m_pPrecede)->GetFrameId() );
 }
 
 void SwSectionFrame::dumpAsXmlAttributes( xmlTextWriterPtr writer ) const
 {
     SwFrame::dumpAsXmlAttributes( writer );
     if ( HasFollow() )
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "follow" ), "%" SAL_PRIuUINT32, GetFollow()->GetFrameId() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "follow" ), "%" SAL_PRIuUINT32, GetFollow()->GetFrameId() );
 
     if (m_pPrecede != nullptr)
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "precede" ), "%" SAL_PRIuUINT32, static_cast<SwSectionFrame*>( m_pPrecede )->GetFrameId() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "precede" ), "%" SAL_PRIuUINT32, static_cast<SwSectionFrame*>( m_pPrecede )->GetFrameId() );
 }
 
 void SwTabFrame::dumpAsXmlAttributes( xmlTextWriterPtr writer ) const
 {
     SwFrame::dumpAsXmlAttributes( writer );
     if ( HasFollow() )
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "follow" ), "%" SAL_PRIuUINT32, GetFollow()->GetFrameId() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "follow" ), "%" SAL_PRIuUINT32, GetFollow()->GetFrameId() );
 
     if (m_pPrecede != nullptr)
-        xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "precede" ), "%" SAL_PRIuUINT32, static_cast<SwTabFrame*>( m_pPrecede )->GetFrameId() );
+        (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "precede" ), "%" SAL_PRIuUINT32, static_cast<SwTabFrame*>( m_pPrecede )->GetFrameId() );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/txtnode/atrfld.cxx b/sw/source/core/txtnode/atrfld.cxx
index f8f326fc8f8f..36151899db9a 100644
--- a/sw/source/core/txtnode/atrfld.cxx
+++ b/sw/source/core/txtnode/atrfld.cxx
@@ -405,14 +405,14 @@ bool SwFormatField::IsProtect() const
 
 void SwFormatField::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatField"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("mpTextField"), "%p", mpTextField);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatField"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("mpTextField"), "%p", mpTextField);
 
     SfxPoolItem::dumpAsXml(pWriter);
     mpField->dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // class SwTextField ////////////////////////////////////////////////////
diff --git a/sw/source/core/txtnode/atrftn.cxx b/sw/source/core/txtnode/atrftn.cxx
index a621f2a41902..884883d10515 100644
--- a/sw/source/core/txtnode/atrftn.cxx
+++ b/sw/source/core/txtnode/atrftn.cxx
@@ -580,29 +580,29 @@ void SwTextFootnote::CheckCondColl()
 
 void SwTextFootnote::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextFootnote"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextFootnote"));
     SwTextAttr::dumpAsXml(pWriter);
 
     if (m_pStartNode)
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("m_pStartNode"));
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_pStartNode"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
                                     BAD_CAST(OString::number(m_pStartNode->GetIndex()).getStr()));
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
     if (m_pTextNode)
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("m_pTextNode"));
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_pTextNode"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
                                     BAD_CAST(OString::number(m_pTextNode->GetIndex()).getStr()));
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_nSeqNo"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_nSeqNo"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
                                 BAD_CAST(OString::number(m_nSeqNo).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/txtnode/chrfmt.cxx b/sw/source/core/txtnode/chrfmt.cxx
index 15a60eeb4bac..04301067ec23 100644
--- a/sw/source/core/txtnode/chrfmt.cxx
+++ b/sw/source/core/txtnode/chrfmt.cxx
@@ -24,18 +24,19 @@
 
 void SwCharFormat::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwCharFormat"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwCharFormat"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"),
+                                      BAD_CAST(GetName().toUtf8().getStr()));
     GetAttrSet().dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void SwCharFormats::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwCharFormats"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwCharFormats"));
     for (size_t i = 0; i < size(); ++i)
         GetFormat(i)->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/txtnode/fmtatr2.cxx b/sw/source/core/txtnode/fmtatr2.cxx
index a474f7a639cf..ff04d9bb0ed9 100644
--- a/sw/source/core/txtnode/fmtatr2.cxx
+++ b/sw/source/core/txtnode/fmtatr2.cxx
@@ -140,11 +140,11 @@ bool SwFormatAutoFormat::PutValue( const uno::Any& , sal_uInt8 )
 
 void SwFormatAutoFormat::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatAutoFormat"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatAutoFormat"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
     mpHandle->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SwFormatINetFormat::SwFormatINetFormat()
diff --git a/sw/source/core/txtnode/ndtxt.cxx b/sw/source/core/txtnode/ndtxt.cxx
index 8bb3aee07cc4..908587b32ea3 100644
--- a/sw/source/core/txtnode/ndtxt.cxx
+++ b/sw/source/core/txtnode/ndtxt.cxx
@@ -5168,44 +5168,44 @@ sal_uInt16 SwTextNode::ResetAllAttr()
 
 void SwTextNode::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextNode"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"), BAD_CAST(OString::number(GetIndex()).getStr()));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextNode"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"), BAD_CAST(OString::number(GetIndex()).getStr()));
 
     OUString sText = GetText();
     for (int i = 0; i < 32; ++i)
         sText = sText.replace(i, '*');
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_Text"));
-    xmlTextWriterWriteString(pWriter, BAD_CAST(sText.toUtf8().getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_Text"));
+    (void)xmlTextWriterWriteString(pWriter, BAD_CAST(sText.toUtf8().getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 
     if (GetFormatColl())
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextFormatColl"));
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetFormatColl()->GetName().toUtf8().getStr()));
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextFormatColl"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetFormatColl()->GetName().toUtf8().getStr()));
+        (void)xmlTextWriterEndElement(pWriter);
     }
 
     if (HasSwAttrSet())
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("SwAttrSet"));
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwAttrSet"));
         GetSwAttrSet().dumpAsXml(pWriter);
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
 
     if (HasHints())
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("SwpHints"));
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwpHints"));
         const SwpHints& rHints = GetSwpHints();
         for (size_t i = 0; i < rHints.Count(); ++i)
             rHints.Get(i)->dumpAsXml(pWriter);
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
 
     if (GetNumRule())
         GetNumRule()->dumpAsXml(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 sal_uInt32 SwTextNode::GetRsid( sal_Int32 nStt, sal_Int32 nEnd ) const
diff --git a/sw/source/core/txtnode/txatbase.cxx b/sw/source/core/txtnode/txatbase.cxx
index cf4583f1473a..c5c0736306fd 100644
--- a/sw/source/core/txtnode/txatbase.cxx
+++ b/sw/source/core/txtnode/txatbase.cxx
@@ -88,15 +88,15 @@ void SwTextAttrEnd::SetEnd(sal_Int32 n)
 
 void SwTextAttr::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextAttr"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s",
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwTextAttr"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s",
                                       BAD_CAST(typeid(*this).name()));
 
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("start"), BAD_CAST(OString::number(m_nStart).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("start"), BAD_CAST(OString::number(m_nStart).getStr()));
     if (End())
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("end"), BAD_CAST(OString::number(*End()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("end"), BAD_CAST(OString::number(*End()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
     const char* pWhich = nullptr;
     std::optional<OString> oValue;
     switch (Which())
@@ -145,9 +145,9 @@ void SwTextAttr::dumpAsXml(xmlTextWriterPtr pWriter) const
         break;
     }
     if (pWhich)
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("which"), BAD_CAST(pWhich));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("which"), BAD_CAST(pWhich));
     if (oValue)
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(oValue->getStr()));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(oValue->getStr()));
     switch (Which())
     {
         case RES_TXTATR_AUTOFMT:
@@ -164,7 +164,7 @@ void SwTextAttr::dumpAsXml(xmlTextWriterPtr pWriter) const
             break;
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/undo/docundo.cxx b/sw/source/core/undo/docundo.cxx
index 6e350836fc20..d1f0eee5fec6 100644
--- a/sw/source/core/undo/docundo.cxx
+++ b/sw/source/core/undo/docundo.cxx
@@ -655,14 +655,14 @@ bool UndoManager::Redo()
 
 void UndoManager::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("swUndoManager"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("swUndoManager"));
     SdrUndoManager::dumpAsXml(pWriter);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_xUndoNodes"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_xUndoNodes"));
     m_xUndoNodes->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void UndoManager::EmptyActionsChanged()
diff --git a/sw/source/core/undo/rolbck.cxx b/sw/source/core/undo/rolbck.cxx
index 2d6a9e5b511e..a1310936c851 100644
--- a/sw/source/core/undo/rolbck.cxx
+++ b/sw/source/core/undo/rolbck.cxx
@@ -66,12 +66,12 @@ OUString SwHistoryHint::GetDescription() const
 
 void SwHistoryHint::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwHistoryHint"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("symbol"), BAD_CAST(typeid(*this).name()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_eWhichId"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwHistoryHint"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("symbol"), BAD_CAST(typeid(*this).name()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_eWhichId"),
                                 BAD_CAST(OString::number(m_eWhichId).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SwHistorySetFormat::SwHistorySetFormat( const SfxPoolItem* pFormatHt, sal_uLong nNd )
@@ -148,8 +148,8 @@ OUString SwHistorySetFormat::GetDescription() const
 
 void SwHistorySetFormat::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwHistorySetFormat"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nNodeIndex"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwHistorySetFormat"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nNodeIndex"),
                                 BAD_CAST(OString::number(m_nNodeIndex).getStr()));
     SwHistoryHint::dumpAsXml(pWriter);
 
@@ -158,7 +158,7 @@ void SwHistorySetFormat::dumpAsXml(xmlTextWriterPtr pWriter) const
         m_pAttr->dumpAsXml(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void SwHistorySetFormat::SetInDoc( SwDoc* pDoc, bool bTmpSet )
@@ -590,7 +590,7 @@ void SwHistoryTextFlyCnt::SetInDoc( SwDoc* pDoc, bool )
 
 void SwHistoryTextFlyCnt::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwHistoryTextFlyCnt"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwHistoryTextFlyCnt"));
     SwHistoryHint::dumpAsXml(pWriter);
 
     if (m_pUndo)
@@ -598,7 +598,7 @@ void SwHistoryTextFlyCnt::dumpAsXml(xmlTextWriterPtr pWriter) const
         m_pUndo->dumpAsXml(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SwHistoryBookmark::SwHistoryBookmark(
@@ -1291,17 +1291,17 @@ void SwHistory::CopyFormatAttr(
 
 void SwHistory::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwHistory"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwHistory"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
-    xmlTextWriterStartElement(pWriter, BAD_CAST("m_SwpHstry"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_SwpHstry"));
     for (const auto& pHistory : m_SwpHstry)
     {
         pHistory->dumpAsXml(pWriter);
     }
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void SwHistory::CopyAttr(
diff --git a/sw/source/core/undo/undel.cxx b/sw/source/core/undo/undel.cxx
index b8570b17c533..f3fbf5eac553 100644
--- a/sw/source/core/undo/undel.cxx
+++ b/sw/source/core/undo/undel.cxx
@@ -1322,11 +1322,11 @@ void SwUndoDelete::SetTableName(const OUString & rName)
 
 void SwUndoDelete::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoDelete"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoDelete"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
     SwUndo::dumpAsXml(pWriter);
     SwUndoSaveContent::dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/undo/undobj.cxx b/sw/source/core/undo/undobj.cxx
index a13f87a7786d..5c2405f32966 100644
--- a/sw/source/core/undo/undobj.cxx
+++ b/sw/source/core/undo/undobj.cxx
@@ -706,15 +706,15 @@ SwUndoSaveContent::~SwUndoSaveContent() COVERITY_NOEXCEPT_FALSE
 
 void SwUndoSaveContent::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoSaveContent"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoSaveContent"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 
     if (m_pHistory)
     {
         m_pHistory->dumpAsXml(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 // This is needed when deleting content. For REDO all contents will be moved
diff --git a/sw/source/core/undo/undobj1.cxx b/sw/source/core/undo/undobj1.cxx
index 83e49c114ae0..0e84af47d5c4 100644
--- a/sw/source/core/undo/undobj1.cxx
+++ b/sw/source/core/undo/undobj1.cxx
@@ -64,14 +64,14 @@ SwUndoFlyBase::~SwUndoFlyBase()
 
 void SwUndoFlyBase::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoFlyBase"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nNodePagePos"),
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoFlyBase"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nNodePagePos"),
                                 BAD_CAST(OString::number(m_nNodePagePos).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nContentPos"),
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nContentPos"),
                                 BAD_CAST(OString::number(m_nContentPos).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nRndId"),
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nRndId"),
                                 BAD_CAST(OString::number(static_cast<int>(m_nRndId)).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_bDelFormat"),
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_bDelFormat"),
                                 BAD_CAST(OString::boolean(m_bDelFormat).getStr()));
 
     SwUndo::dumpAsXml(pWriter);
@@ -82,7 +82,7 @@ void SwUndoFlyBase::dumpAsXml(xmlTextWriterPtr pWriter) const
         m_pFrameFormat->dumpAsXml(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void SwUndoFlyBase::InsFly(::sw::UndoRedoContext & rContext, bool bShowSelFrame)
diff --git a/sw/source/core/undo/undraw.cxx b/sw/source/core/undo/undraw.cxx
index 060cc08e6559..b10cae23f0a3 100644
--- a/sw/source/core/undo/undraw.cxx
+++ b/sw/source/core/undo/undraw.cxx
@@ -542,25 +542,25 @@ void SwUndoDrawDelete::AddObj( SwDrawFrameFormat* pFormat,
 
 void SwUndoDrawDelete::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoDrawDelete"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoDrawDelete"));
 
     for (size_t i = 0; i < m_pMarkList->GetMarkCount(); ++i)
     {
         SwUndoGroupObjImpl& rObj = m_pObjArray[i];
-        xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoGroupObjImpl"));
-        xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoGroupObjImpl"));
+        (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"),
                                     BAD_CAST(OString::number(i).getStr()));
 
         if (rObj.pFormat)
         {
-            xmlTextWriterStartElement(pWriter, BAD_CAST("pFormat"));
+            (void)xmlTextWriterStartElement(pWriter, BAD_CAST("pFormat"));
             rObj.pFormat->dumpAsXml(pWriter);
-            xmlTextWriterEndElement(pWriter);
+            (void)xmlTextWriterEndElement(pWriter);
         }
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/undo/untblk.cxx b/sw/source/core/undo/untblk.cxx
index f907be8013e1..5fd92fe63eca 100644
--- a/sw/source/core/undo/untblk.cxx
+++ b/sw/source/core/undo/untblk.cxx
@@ -187,9 +187,9 @@ bool SwUndoInserts::IsCreateUndoForNewFly(SwFormatAnchor const& rAnchor,
 
 void SwUndoInserts::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoInserts"));
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
-    xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s",
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoInserts"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s",
                                       BAD_CAST(typeid(*this).name()));
 
     SwUndo::dumpAsXml(pWriter);
@@ -197,25 +197,25 @@ void SwUndoInserts::dumpAsXml(xmlTextWriterPtr pWriter) const
 
     if (m_pFrameFormats)
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("m_pFrameFormats"));
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_pFrameFormats"));
         for (const auto& pFormat : *m_pFrameFormats)
         {
             pFormat->dumpAsXml(pWriter);
         }
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
 
     if (!m_FlyUndos.empty())
     {
-        xmlTextWriterStartElement(pWriter, BAD_CAST("m_FlyUndos"));
+        (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_FlyUndos"));
         for (const auto& pFly : m_FlyUndos)
         {
             pFly->dumpAsXml(pWriter);
         }
-        xmlTextWriterEndElement(pWriter);
+        (void)xmlTextWriterEndElement(pWriter);
     }
 
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 SwUndoInserts::~SwUndoInserts()
diff --git a/sw/source/core/view/viewsh.cxx b/sw/source/core/view/viewsh.cxx
index 3940f36570cb..4ec987fd777b 100644
--- a/sw/source/core/view/viewsh.cxx
+++ b/sw/source/core/view/viewsh.cxx
@@ -137,8 +137,8 @@ bool SwViewShell::isOutputToWindow() const
 
 void SwViewShell::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwViewShell"));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwViewShell"));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 static void
diff --git a/sw/source/uibase/uiview/viewprt.cxx b/sw/source/uibase/uiview/viewprt.cxx
index 0617b8387fe9..be7337c25654 100644
--- a/sw/source/uibase/uiview/viewprt.cxx
+++ b/sw/source/uibase/uiview/viewprt.cxx
@@ -266,11 +266,11 @@ int SwView::getPart() const
 
 void SwView::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwView"));
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwView"));
     SfxViewShell::dumpAsXml(pWriter);
     if (m_pWrtShell)
         m_pWrtShell->dumpAsXml(pWriter);
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 void SwView::SetRedlineAuthor(const OUString& rAuthor)
diff --git a/sw/source/uibase/utlui/attrdesc.cxx b/sw/source/uibase/utlui/attrdesc.cxx
index e35e8d31e01c..6331992935c4 100644
--- a/sw/source/uibase/utlui/attrdesc.cxx
+++ b/sw/source/uibase/utlui/attrdesc.cxx
@@ -540,10 +540,10 @@ bool SwFormatEditInReadonly::GetPresentation
 
 void SwFormatEditInReadonly::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatEditInReadonly"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatEditInReadonly"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 bool SwFormatLayoutSplit::GetPresentation
@@ -834,10 +834,10 @@ bool SwFormatFollowTextFlow::GetPresentation( SfxItemPresentation ePres,
 
 void SwFormatFollowTextFlow::dumpAsXml(xmlTextWriterPtr pWriter) const
 {
-    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatFollowTextFlow"));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
-    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
-    xmlTextWriterEndElement(pWriter);
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatFollowTextFlow"));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
+    (void)xmlTextWriterEndElement(pWriter);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/tools/source/xml/XmlWriter.cxx b/tools/source/xml/XmlWriter.cxx
index d05ec2203bc6..93c4f0cdea96 100644
--- a/tools/source/xml/XmlWriter.cxx
+++ b/tools/source/xml/XmlWriter.cxx
@@ -66,14 +66,14 @@ bool XmlWriter::startDocument(sal_Int32 nIndent, bool bWriteXmlHeader)
         return false;
     xmlTextWriterSetIndent(mpImpl->mpWriter, nIndent);
     if (mpImpl->mbWriteXmlHeader)
-        xmlTextWriterStartDocument(mpImpl->mpWriter, nullptr, "UTF-8", nullptr);
+        (void)xmlTextWriterStartDocument(mpImpl->mpWriter, nullptr, "UTF-8", nullptr);
     return true;
 }
 
 void XmlWriter::endDocument()
 {
     if (mpImpl->mbWriteXmlHeader)
-        xmlTextWriterEndDocument(mpImpl->mpWriter);
+        (void)xmlTextWriterEndDocument(mpImpl->mpWriter);
     xmlFreeTextWriter(mpImpl->mpWriter);
     mpImpl->mpWriter = nullptr;
 }
@@ -89,7 +89,7 @@ void XmlWriter::startElement(const OString& sPrefix, const OString& sName,
     if (!sNamespaceUri.isEmpty())
         xmlNamespaceUri = xmlCharStrdup(sNamespaceUri.getStr());
 
-    xmlTextWriterStartElementNS(mpImpl->mpWriter, xmlPrefix, xmlName, xmlNamespaceUri);
+    (void)xmlTextWriterStartElementNS(mpImpl->mpWriter, xmlPrefix, xmlName, xmlNamespaceUri);
 
     xmlFree(xmlName);
     if (!sPrefix.isEmpty())
@@ -101,11 +101,11 @@ void XmlWriter::startElement(const OString& sPrefix, const OString& sName,
 void XmlWriter::startElement(const OString& sName)
 {
     xmlChar* xmlName = xmlCharStrdup(sName.getStr());
-    xmlTextWriterStartElement(mpImpl->mpWriter, xmlName);
+    (void)xmlTextWriterStartElement(mpImpl->mpWriter, xmlName);
     xmlFree(xmlName);
 }
 
-void XmlWriter::endElement() { xmlTextWriterEndElement(mpImpl->mpWriter); }
+void XmlWriter::endElement() { (void)xmlTextWriterEndElement(mpImpl->mpWriter); }
 
 void XmlWriter::attributeBase64(const OString& rsName, std::vector<sal_uInt8> const& rValueInBytes)
 {
@@ -116,9 +116,9 @@ void XmlWriter::attributeBase64(const OString& rsName, std::vector<sal_uInt8> co
 void XmlWriter::attributeBase64(const OString& rsName, std::vector<char> const& rValueInBytes)
 {
     xmlChar* xmlName = xmlCharStrdup(rsName.getStr());
-    xmlTextWriterStartAttribute(mpImpl->mpWriter, xmlName);
-    xmlTextWriterWriteBase64(mpImpl->mpWriter, rValueInBytes.data(), 0, rValueInBytes.size());
-    xmlTextWriterEndAttribute(mpImpl->mpWriter);
+    (void)xmlTextWriterStartAttribute(mpImpl->mpWriter, xmlName);
+    (void)xmlTextWriterWriteBase64(mpImpl->mpWriter, rValueInBytes.data(), 0, rValueInBytes.size());
+    (void)xmlTextWriterEndAttribute(mpImpl->mpWriter);
     xmlFree(xmlName);
 }
 
@@ -126,7 +126,7 @@ void XmlWriter::attribute(const OString& name, const OString& value)
 {
     xmlChar* xmlName = xmlCharStrdup(name.getStr());
     xmlChar* xmlValue = xmlCharStrdup(value.getStr());
-    xmlTextWriterWriteAttribute(mpImpl->mpWriter, xmlName, xmlValue);
+    (void)xmlTextWriterWriteAttribute(mpImpl->mpWriter, xmlName, xmlValue);
     xmlFree(xmlValue);
     xmlFree(xmlName);
 }
@@ -149,7 +149,7 @@ void XmlWriter::attributeDouble(const OString& name, const double aNumber)
 void XmlWriter::content(const OString& sValue)
 {
     xmlChar* xmlValue = xmlCharStrdup(sValue.getStr());
-    xmlTextWriterWriteString(mpImpl->mpWriter, xmlValue);
+    (void)xmlTextWriterWriteString(mpImpl->mpWriter, xmlValue);
     xmlFree(xmlValue);
 }
 
diff --git a/writerfilter/source/dmapper/TagLogger.cxx b/writerfilter/source/dmapper/TagLogger.cxx
index a7443f056d29..efe1485bc4fe 100644
--- a/writerfilter/source/dmapper/TagLogger.cxx
+++ b/writerfilter/source/dmapper/TagLogger.cxx
@@ -77,15 +77,15 @@ namespace writerfilter
     {
         if (!pWriter)
             return;
-        xmlTextWriterStartDocument( pWriter, nullptr, nullptr, nullptr );
-        xmlTextWriterStartElement( pWriter, BAD_CAST( "root" ) );
+        (void)xmlTextWriterStartDocument( pWriter, nullptr, nullptr, nullptr );
+        (void)xmlTextWriterStartElement( pWriter, BAD_CAST( "root" ) );
     }
 
     void TagLogger::endDocument()
     {
         if (!pWriter)
             return;
-        xmlTextWriterEndDocument( pWriter );
+        (void)xmlTextWriterEndDocument( pWriter );
         xmlFreeTextWriter( pWriter );
         pWriter = nullptr;
     }
@@ -149,7 +149,7 @@ struct TheTagLogger:
         if (!pWriter)
             return;
         xmlChar* xmlName = xmlCharStrdup( name.c_str() );
-        xmlTextWriterStartElement( pWriter, xmlName );
+        (void)xmlTextWriterStartElement( pWriter, xmlName );
         xmlFree( xmlName );
     }
 #endif
@@ -160,7 +160,7 @@ struct TheTagLogger:
             return;
         xmlChar* xmlName = xmlCharStrdup( name.c_str() );
         xmlChar* xmlValue = xmlCharStrdup( value.c_str() );
-        xmlTextWriterWriteAttribute( pWriter, xmlName, xmlValue );
+        (void)xmlTextWriterWriteAttribute( pWriter, xmlName, xmlValue );
 
         xmlFree( xmlValue );
         xmlFree( xmlName );
@@ -177,7 +177,7 @@ struct TheTagLogger:
         if (!pWriter)
             return;
         xmlChar* xmlName = xmlCharStrdup( name.c_str() );
-        xmlTextWriterWriteFormatAttribute( pWriter, xmlName,
+        (void)xmlTextWriterWriteFormatAttribute( pWriter, xmlName,
                "%" SAL_PRIuUINT32, value );
         xmlFree( xmlName );
     }
@@ -194,12 +194,12 @@ struct TheTagLogger:
         xmlChar* xmlName = xmlCharStrdup( name.c_str() );
         if ( aAny >>= nInt )
         {
-            xmlTextWriterWriteFormatAttribute( pWriter, xmlName,
+            (void)xmlTextWriterWriteFormatAttribute( pWriter, xmlName,
                    "%" SAL_PRIdINT32, nInt );
         }
         else if ( aAny >>= nFloat )
         {
-            xmlTextWriterWriteFormatAttribute( pWriter, xmlName,
+            (void)xmlTextWriterWriteFormatAttribute( pWriter, xmlName,
                    "%f", nFloat );
         }
         else if ( aAny >>= aStr )
@@ -214,7 +214,7 @@ struct TheTagLogger:
         if (!pWriter)
             return;
         xmlChar* xmlChars = xmlCharStrdup( rChars.c_str() );
-        xmlTextWriterWriteString( pWriter, xmlChars );
+        (void)xmlTextWriterWriteString( pWriter, xmlChars );
         xmlFree( xmlChars );
     }
 
@@ -227,7 +227,7 @@ struct TheTagLogger:
     {
         if (!pWriter)
             return;
-        xmlTextWriterEndElement( pWriter );
+        (void)xmlTextWriterEndElement( pWriter );
     }
 
 #endif