use unique_ptr in hwpfilter

Change-Id: I3491777281912e095c9222e83028d358d6826841
Reviewed-on: https://gerrit.libreoffice.org/65522
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

hwpfilter/source/cspline.cxx

@@ -53,8 +53,8 @@
 #include "cspline.h"
 #include "solver.h"
 
-void NaturalSpline (int N, const double* x, const double* a, double*& b, double*& c,
-    double*& d)
+void NaturalSpline (int N, const double* x, const double* a, std::unique_ptr<double[]>& b, std::unique_ptr<double[]>& c,
+    std::unique_ptr<double[]>& d)
 {
   const double oneThird = 1.0/3.0;
 
@@ -96,9 +96,9 @@ void NaturalSpline (int N, const double* x, const double* a, double*& b, double*
   ell[N] = 1.0;
   z[N] = 0.0;
 
-  b = new double[N];
-  c = new double[N+1];
-  d = new double[N];
+  b.reset(new double[N]);
+  c.reset(new double[N+1]);
+  d.reset(new double[N]);
 
   c[N] = 0.0;
 
@@ -111,8 +111,8 @@ void NaturalSpline (int N, const double* x, const double* a, double*& b, double*
   }
 }
 
-void PeriodicSpline (int N, const double* x, const double* a, double*& b, double*& c,
-    double*& d)
+void PeriodicSpline (int N, const double* x, const double* a, std::unique_ptr<double[]>& b, std::unique_ptr<double[]>& c,
+    std::unique_ptr<double[]>& d)
 {
   std::unique_ptr<double[]> h(new double[N]);
   int i;
@@ -145,11 +145,11 @@ void PeriodicSpline (int N, const double* x, const double* a, double*& b, double
   c[N] = 3.0f*((a[1]-a[0])/h[0] - (a[0]-a[N-1])/h[N-1]);
 
   // solve for c[0] through c[N]
-  mgcLinearSystemD::Solve(N+1,mat,c);
+  mgcLinearSystemD::Solve(N+1,mat,c.get());
 
   const double oneThird = 1.0/3.0;
-  b = new double[N];
-  d = new double[N];
+  b.reset(new double[N]);
+  d.reset(new double[N]);
   for (i = 0; i < N; i++)
   {
     b[i] = (a[i+1]-a[i])/h[i] - oneThird*(c[i+1]+2.0f*c[i])*h[i];

hwpfilter/source/cspline.h

@@ -20,10 +20,10 @@
 #ifndef INCLUDED_HWPFILTER_SOURCE_CSPLINE_H
 #define INCLUDED_HWPFILTER_SOURCE_CSPLINE_H
 
-void NaturalSpline (int N, const double* x, const double* a, double*& b, double*& c,
-    double*& d);
-void PeriodicSpline (int N, const double* x, const double* a, double*& b, double*& c,
-    double*& d);
+void NaturalSpline (int N, const double* x, const double* a, std::unique_ptr<double[]>& b, std::unique_ptr<double[]>& c,
+    std::unique_ptr<double[]>& d);
+void PeriodicSpline (int N, const double* x, const double* a, std::unique_ptr<double[]>& b, std::unique_ptr<double[]>& c,
+    std::unique_ptr<double[]>& d);
 
 #endif // INCLUDED_HWPFILTER_SOURCE_CSPLINE_H
 

hwpfilter/source/formula.cxx

@@ -613,8 +613,6 @@ void Formula::parse()
      if( res ){
           makeMathML( res );
      }
-     for (const auto &node : nodelist)
-         delete node;
      nodelist.clear();
 }
 

hwpfilter/source/hwpread.cxx

@@ -307,7 +307,8 @@ bool TxtBox::Read(HWPFile & hwpf)
     hwpf.ReadParaList(caption);
 
     if( type == 0 ){ // if table?
-        TCell* *pArr = ::comphelper::newArray_null<TCell *>(ncell);
+        std::unique_ptr<TCell*[]> pArr(new TCell*[ncell]);
+        std::fill(pArr.get(), pArr.get() + ncell, nullptr);
         if (!pArr) {
               return hwpf.SetState(HWP_InvalidFileFormat);
         }
@@ -356,7 +357,6 @@ bool TxtBox::Read(HWPFile & hwpf)
         tbl->box = this;
         m_pTable = tbl.get();
         hwpf.AddTable(std::move(tbl));
-        delete[] pArr;
     }
     else
         m_pTable = nullptr;
@@ -461,12 +461,12 @@ bool Picture::Read(HWPFile & hwpf)
         if (pictype == PICTYPE_DRAW)
         {
             HIODev* pOldMem = hmem;
-            HMemIODev* pNewMem = new HMemIODev(reinterpret_cast<char *>(follow.data()), follow_block_size);
-            hmem = pNewMem;
+            std::unique_ptr<HMemIODev> pNewMem(new HMemIODev(reinterpret_cast<char *>(follow.data()), follow_block_size));
+            hmem = pNewMem.get();
             LoadDrawingObjectBlock(this);
             style.cell = picinfo.picdraw.hdo;
-            assert(hmem == pNewMem);
-            delete pNewMem;
+            assert(hmem == pNewMem.get());
+            pNewMem.reset();
             hmem = pOldMem;
         }
         else if (follow_block_size >= 4)

hwpfilter/source/hwpreader.cxx

@@ -4360,15 +4360,15 @@ void HwpReader::makePictureDRAW(HWPDrawingObject *drawobj, Picture * hbox)
                               int n, i;
                               n = drawobj->u.freeform.npt;
 
-                              double *xarr = new double[n+1];
-                              double *yarr = new double[n+1];
-                              double *tarr = new double[n+1];
+                              std::unique_ptr<double[]> xarr( new double[n+1] );
+                              std::unique_ptr<double[]> yarr( new double[n+1] );
+                              std::unique_ptr<double[]> tarr( new double[n+1] );
 
-                              double *xb = nullptr;
-                              double *yb = nullptr;
+                              std::unique_ptr<double[]> xb;
+                              std::unique_ptr<double[]> yb;
 
-                              double *carr = nullptr;
-                              double *darr = nullptr;
+                              std::unique_ptr<double[]> carr;
+                              std::unique_ptr<double[]> darr;
 
 
                               for( i = 0 ; i < n ; i++ ){
@@ -4381,22 +4381,18 @@ void HwpReader::makePictureDRAW(HWPDrawingObject *drawobj, Picture * hbox)
                               tarr[n] = n;
 
                               if( !bIsNatural ){
-                                  PeriodicSpline(n, tarr, xarr, xb, carr, darr);
+                                  PeriodicSpline(n, tarr.get(), xarr.get(), xb, carr, darr);
                                   // prevent memory leak
-                                  delete[] carr;
-                                  carr = nullptr;
-                                  delete[] darr;
-                                  darr = nullptr;
-                                  PeriodicSpline(n, tarr, yarr, yb, carr, darr);
+                                  carr.reset();
+                                  darr.reset();
+                                  PeriodicSpline(n, tarr.get(), yarr.get(), yb, carr, darr);
                               }
                               else{
-                                  NaturalSpline(n, tarr, xarr, xb, carr, darr);
+                                  NaturalSpline(n, tarr.get(), xarr.get(), xb, carr, darr);
                                   // prevent memory leak
-                                  delete[] carr;
-                                  carr = nullptr;
-                                  delete[] darr;
-                                  darr = nullptr;
-                                  NaturalSpline(n, tarr, yarr, yb, carr, darr);
+                                  carr.reset();
+                                  darr.reset();
+                                  NaturalSpline(n, tarr.get(), yarr.get(), yb, carr, darr);
                               }
 
                               sprintf(buf, "M%d %dC%d %d", WTSM(xarr[0]), WTSM(yarr[0]),
@@ -4418,15 +4414,6 @@ void HwpReader::makePictureDRAW(HWPDrawingObject *drawobj, Picture * hbox)
 
                                   oustr.append(ascii(buf));
                               }
-                              delete[] tarr;
-                              delete[] xarr;
-                              delete[] yarr;
-
-                              delete[] xb;
-                              delete[] yb;
-
-                              delete[] carr;
-                              delete[] darr;
                           }
 
                     padd("svg:d", sXML_CDATA, oustr.makeStringAndClear());

hwpfilter/source/nodes.h

@@ -22,6 +22,7 @@
 
 #include <sal/config.h>
 
+#include <memory>
 #include <vector>
 #include <stdio.h>
 #include <stdlib.h>
@@ -94,7 +95,7 @@ public:
      Node *child;
      Node *next;
 };
-extern std::vector<Node *> nodelist;
+extern std::vector<std::unique_ptr<Node>> nodelist;
 
 #endif
 

hwpfilter/source/solver.cxx

@@ -35,11 +35,9 @@ std::unique_ptr<std::unique_ptr<double[]>[]> mgcLinearSystemD::NewMatrix (int N)
   return A;
 }
 
-double* mgcLinearSystemD::NewVector (int N)
+std::unique_ptr<double[]> mgcLinearSystemD::NewVector (int N)
 {
-  double* B = new double[N];
-  if ( !B )
-    return nullptr;
+  std::unique_ptr<double[]> B(new double[N]);
 
   for (int row = 0; row < N; row++)
     B[row] = 0;

hwpfilter/source/solver.h

@@ -24,7 +24,7 @@ class mgcLinearSystemD
 {
 public:
   static std::unique_ptr<std::unique_ptr<double[]>[]> NewMatrix (int N);
-  static double* NewVector (int N);
+  static std::unique_ptr<double[]> NewVector (int N);
 
   static bool Solve (int N, std::unique_ptr<std::unique_ptr<double[]>[]>& A, double* b);
   // Input: