BASIC : Use std::unique_ptr in SbiExpression and SbiExpList

Change-Id: I6f09615d19560673319e103af36c40c94ea77f12
Reviewed-on: https://gerrit.libreoffice.org/22186
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Michael Stahl <mstahl@redhat.com>

3 files changed, 30 insertions, 41 deletions

diff --git a/basic/source/comp/exprtree.cxx b/basic/source/comp/exprtree.cxx
index 5eb665b653ff..d0cb9dbd8d73 100644
--- a/basic/source/comp/exprtree.cxx
+++ b/basic/source/comp/exprtree.cxx
@@ -21,6 +21,7 @@
 #include "parser.hxx"
 #include <basic/sbx.hxx>
 #include "expr.hxx"
+#include <o3tl/make_unique.hxx>
 
 /***************************************************************************
 |*
@@ -36,7 +37,7 @@ SbiExpression::SbiExpression( SbiParser* p, SbiExprType t,
     nParenLevel = 0;
     eCurExpr = t;
     m_eMode = eMode;
-    pExpr = (t != SbSTDEXPR ) ? Term( pKeywordSymbolInfo ) : Boolean();
+    pExpr.reset((t != SbSTDEXPR ) ? Term( pKeywordSymbolInfo ) : Boolean());
     if( t != SbSYMBOL )
     {
         pExpr->Optimize(pParser);
@@ -58,7 +59,7 @@ SbiExpression::SbiExpression( SbiParser* p, double n, SbxDataType t )
     nParenLevel = 0;
     eCurExpr = SbOPERAND;
     m_eMode = EXPRMODE_STANDARD;
-    pExpr = new SbiExprNode( n, t );
+    pExpr = o3tl::make_unique<SbiExprNode>( n, t );
     pExpr->Optimize(pParser);
 }
 
@@ -69,13 +70,10 @@ SbiExpression::SbiExpression( SbiParser* p, const SbiSymDef& r, SbiExprList* pPa
     nParenLevel = 0;
     eCurExpr = SbOPERAND;
     m_eMode = EXPRMODE_STANDARD;
-    pExpr = new SbiExprNode( r, SbxVARIANT, pPar );
+    pExpr = o3tl::make_unique<SbiExprNode>( r, SbxVARIANT, pPar );
 }
 
-SbiExpression::~SbiExpression()
-{
-    delete pExpr;
-}
+SbiExpression::~SbiExpression() { }
 
 // reading in a complete identifier
 // an identifier has the following form:
@@ -860,8 +858,7 @@ SbiConstExpression::SbiConstExpression( SbiParser* p ) : SbiExpression( p )
 
             if( bIsBool )
             {
-                delete pExpr;
-                pExpr = new SbiExprNode( (bBoolVal ? SbxTRUE : SbxFALSE), SbxINTEGER );
+                pExpr = o3tl::make_unique<SbiExprNode>( (bBoolVal ? SbxTRUE : SbxFALSE), SbxINTEGER );
                 eType = pExpr->GetType();
                 nVal = pExpr->nVal;
             }
@@ -924,22 +921,16 @@ SbiExprList::SbiExprList( )
     bBracket = false;
 }
 
-SbiExprList::~SbiExprList()
-{
-    for (auto pExpr: aData)
-    {
-        delete pExpr;
-    }
-}
+SbiExprList::~SbiExprList() {}
 
-SbiExpression* SbiExprList::Get( short n )
+SbiExpression* SbiExprList::Get( size_t n )
 {
-    return aData[n];
+    return aData[n].get();
 }
 
-void SbiExprList::addExpression( SbiExpression* pExpr )
+void SbiExprList::addExpression( std::unique_ptr<SbiExpression>&& pExpr )
 {
-    aData.push_back(pExpr);
+    aData.push_back(std::move(pExpr));
 }
 
 // the parameter list is completely parsed
@@ -988,11 +979,11 @@ SbiExprList* SbiExprList::ParseParameters( SbiParser* pParser, bool bStandaloneE
     // read in parameter table and lay down in correct order!
     while( !pExprList->bError )
     {
-        SbiExpression *pExpr;
+        std::unique_ptr<SbiExpression> pExpr;
         // missing argument
         if( eTok == COMMA )
         {
-            pExpr = new SbiExpression( pParser, 0, SbxEMPTY );
+            pExpr = o3tl::make_unique<SbiExpression>( pParser, 0, SbxEMPTY );
         }
         // named arguments: either .name= or name:=
         else
@@ -1007,7 +998,7 @@ SbiExprList* SbiExprList::ParseParameters( SbiParser* pParser, bool bStandaloneE
 
             if( bAssumeExprLParenMode )
             {
-                pExpr = new SbiExpression( pParser, SbSTDEXPR, EXPRMODE_LPAREN_PENDING );
+                pExpr = o3tl::make_unique<SbiExpression>( pParser, SbSTDEXPR, EXPRMODE_LPAREN_PENDING );
                 bAssumeExprLParenMode = false;
 
                 SbiExprMode eModeAfter = pExpr->m_eMode;
@@ -1027,13 +1018,12 @@ SbiExprList* SbiExprList::ParseParameters( SbiParser* pParser, bool bStandaloneE
                 else if( eModeAfter == EXPRMODE_EMPTY_PAREN )
                 {
                     pExprList->bBracket = true;
-                    delete pExpr;
                     return pExprList;
                 }
             }
             else
             {
-                pExpr = new SbiExpression( pParser );
+                pExpr = o3tl::make_unique<SbiExpression>( pParser );
             }
             if( bByVal && pExpr->IsLvalue() )
             {
@@ -1047,16 +1037,14 @@ SbiExprList* SbiExprList::ParseParameters( SbiParser* pParser, bool bStandaloneE
                     // VBA mode: name:=
                     // SbiExpression::Term() has made as string out of it
                     aName = pExpr->GetString();
-                    delete pExpr;
                     pParser->Next();
-                    pExpr = new SbiExpression( pParser );
+                    pExpr = o3tl::make_unique<SbiExpression>( pParser );
                 }
                 pExpr->GetName() = aName;
             }
         }
-        pExprList->addExpression(pExpr);
         pExprList->bError = pExprList->bError || !pExpr->IsValid();
-
+        pExprList->aData.push_back(std::move(pExpr));
         if( bAssumeArrayMode )
         {
             break;
@@ -1114,23 +1102,23 @@ SbiExprList* SbiExprList::ParseDimList( SbiParser* pParser )
         SbiToken eTok;
         for( ;; )
         {
-            SbiExpression* pExpr1 = new SbiExpression( pParser );
+            auto pExpr1 = o3tl::make_unique<SbiExpression>( pParser );
             eTok = pParser->Next();
             if( eTok == TO )
             {
-                SbiExpression* pExpr2 = new SbiExpression( pParser );
+                auto pExpr2 = o3tl::make_unique<SbiExpression>( pParser );
                 pExpr1->ConvertToIntConstIfPossible(), pExpr2->ConvertToIntConstIfPossible();
                 eTok = pParser->Next();
                 pExprList->bError = pExprList->bError || !pExpr1->IsValid() || !pExpr2->IsValid();
-                pExprList->addExpression(pExpr1);
-                pExprList->addExpression(pExpr2);
+                pExprList->aData.push_back(std::move(pExpr1));
+                pExprList->aData.push_back(std::move(pExpr2));
             }
             else
             {
                 pExpr1->SetBased();
                 pExpr1->ConvertToIntConstIfPossible();
                 pExprList->bError = pExprList->bError || !pExpr1->IsValid();
-                pExprList->addExpression(pExpr1);
+                pExprList->aData.push_back(std::move(pExpr1));
             }
             pExprList->nDim++;
             if( eTok == RPAREN ) break;
diff --git a/basic/source/comp/parser.cxx b/basic/source/comp/parser.cxx
index 48acf02fa837..ba38a1b25cf1 100644
--- a/basic/source/comp/parser.cxx
+++ b/basic/source/comp/parser.cxx
@@ -23,6 +23,7 @@
 #include <com/sun/star/script/ModuleType.hpp>
 #include <svtools/miscopt.hxx>
 #include <rtl/character.hxx>
+#include <o3tl/make_unique.hxx>
 
 struct SbiParseStack {              // "Stack" for statement-blocks
     SbiParseStack* pNext;           // Chain
@@ -510,10 +511,10 @@ void SbiParser::Symbol( const KeywordSymbolInfo* pKeywordSymbolInfo )
                 if( nParCount == 2 || nParCount == 3 )
                 {
                     if( nParCount == 2 )
-                        pPar->addExpression( new SbiExpression( this, -1, SbxLONG ) );
+                        pPar->addExpression( o3tl::make_unique<SbiExpression>( this, -1, SbxLONG ) );
 
                     TestToken( EQ );
-                    pPar->addExpression( new SbiExpression( this ) );
+                    pPar->addExpression( o3tl::make_unique<SbiExpression>( this ) );
 
                     bSpecialMidHandling = true;
                 }
diff --git a/basic/source/inc/expr.hxx b/basic/source/inc/expr.hxx
index 09fed34fdad6..61a5f6b6f7bb 100644
--- a/basic/source/inc/expr.hxx
+++ b/basic/source/inc/expr.hxx
@@ -160,7 +160,7 @@ class SbiExpression {
 protected:
     OUString      aArgName;
     SbiParser*    pParser;
-    SbiExprNode*   pExpr;            // expression tree
+    std::unique_ptr<SbiExprNode>   pExpr; // expression tree
     SbiExprType   eCurExpr;         // type of expression
     SbiExprMode   m_eMode;          // expression context
     bool          bBased;           // true: easy DIM-part (+BASE)
@@ -199,7 +199,7 @@ public:
     void ConvertToIntConstIfPossible() { pExpr->ConvertToIntConstIfPossible();     }
     const OUString& GetString()     { return pExpr->GetString();  }
     SbiSymDef* GetRealVar()         { return pExpr->GetRealVar(); }
-    SbiExprNode* GetExprNode()      { return pExpr; }
+    SbiExprNode* GetExprNode()      { return pExpr.get();         }
     SbxDataType GetType()           { return pExpr->GetType();    }
     void Gen( RecursiveMode eRecMode = UNDEFINED );
 };
@@ -217,7 +217,7 @@ public:                             // numeric constant
 };
 
 class SbiExprList final {            // class for parameters and dims
-    std::vector<SbiExpression*> aData;
+    std::vector<std::unique_ptr<SbiExpression>> aData;
     short nDim;
     bool  bError;
     bool  bBracket;
@@ -230,9 +230,9 @@ public:
     bool  IsValid()                 { return !bError; }
     short GetSize()                 { return aData.size();    }
     short GetDims()                 { return nDim;            }
-    SbiExpression* Get( short );
+    SbiExpression* Get( size_t );
     void  Gen( SbiCodeGen& rGen);                    // code generation
-    void addExpression( SbiExpression* pExpr );
+    void addExpression( std::unique_ptr<SbiExpression>&& pExpr  );
 };
 
 #endif