Use unique_ptr in CFXA_FM expressions

xfa/fxfa/fm2js/xfa_simpleexpression.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fxfa/fm2js/xfa_simpleexpression.h"
 
 #include <utility>
 
@@ skipping 191 matching lines @@
   } else if (tempStr == FX_WSTRC(L"$layout")) {
     tempStr = FX_WSTRC(L"xfa.layout");
   } else if (tempStr == FX_WSTRC(L"$template")) {
     tempStr = FX_WSTRC(L"xfa.template");
   } else if (tempStr[0] == L'!') {
     tempStr = EXCLAMATION_IN_IDENTIFIER + tempStr.Mid(1);
   }
   javascript << tempStr;
 }
 
-CXFA_FMUnaryExpression::CXFA_FMUnaryExpression(uint32_t line,
-                                               XFA_FM_TOKEN op,
-                                               CXFA_FMSimpleExpression* pExp)
-    : CXFA_FMSimpleExpression(line, op), m_pExp(pExp) {}
+CXFA_FMUnaryExpression::CXFA_FMUnaryExpression(
+    uint32_t line,
+    XFA_FM_TOKEN op,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp)
+    : CXFA_FMSimpleExpression(line, op), m_pExp(std::move(pExp)) {}
 
 CXFA_FMUnaryExpression::~CXFA_FMUnaryExpression() {}
 
 void CXFA_FMUnaryExpression::ToJavaScript(CFX_WideTextBuf& javascript) {}
 
-CXFA_FMBinExpression::CXFA_FMBinExpression(uint32_t line,
-                                           XFA_FM_TOKEN op,
-                                           CXFA_FMSimpleExpression* pExp1,
-                                           CXFA_FMSimpleExpression* pExp2)
-    : CXFA_FMSimpleExpression(line, op), m_pExp1(pExp1), m_pExp2(pExp2) {}
+CXFA_FMBinExpression::CXFA_FMBinExpression(
+    uint32_t line,
+    XFA_FM_TOKEN op,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp1,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2)
+    : CXFA_FMSimpleExpression(line, op),
+      m_pExp1(std::move(pExp1)),
+      m_pExp2(std::move(pExp2)) {}
 
 CXFA_FMBinExpression::~CXFA_FMBinExpression() {}
 
 void CXFA_FMBinExpression::ToJavaScript(CFX_WideTextBuf& javascript) {}
 
-CXFA_FMAssignExpression::CXFA_FMAssignExpression(uint32_t line,
-                                                 XFA_FM_TOKEN op,
-                                                 CXFA_FMSimpleExpression* pExp1,
-                                                 CXFA_FMSimpleExpression* pExp2)
-    : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
+CXFA_FMAssignExpression::CXFA_FMAssignExpression(
+    uint32_t line,
+    XFA_FM_TOKEN op,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp1,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2)
+    : CXFA_FMBinExpression(line, op, std::move(pExp1), std::move(pExp2)) {}
 
 void CXFA_FMAssignExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << FX_WSTRC(L"if (");
   javascript << gs_lpStrExpFuncName[ISFMOBJECT];
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L"))\n{\n");
   javascript << gs_lpStrExpFuncName[ASSIGN];
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
@@ skipping 44 matching lines @@
     m_pExp1->ToJavaScript(javascript);
     javascript << FX_WSTRC(L", ");
     m_pExp2->ToJavaScript(javascript);
     javascript << FX_WSTRC(L");\n}\n");
   }
 }
 
 CXFA_FMLogicalOrExpression::CXFA_FMLogicalOrExpression(
     uint32_t line,
     XFA_FM_TOKEN op,
-    CXFA_FMSimpleExpression* pExp1,
-    CXFA_FMSimpleExpression* pExp2)
-    : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp1,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2)
+    : CXFA_FMBinExpression(line, op, std::move(pExp1), std::move(pExp2)) {}
 
 void CXFA_FMLogicalOrExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[LOGICALOR];
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMLogicalAndExpression::CXFA_FMLogicalAndExpression(
     uint32_t line,
     XFA_FM_TOKEN op,
-    CXFA_FMSimpleExpression* pExp1,
-    CXFA_FMSimpleExpression* pExp2)
-    : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp1,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2)
+    : CXFA_FMBinExpression(line, op, std::move(pExp1), std::move(pExp2)) {}
 
 void CXFA_FMLogicalAndExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[LOGICALAND];
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMEqualityExpression::CXFA_FMEqualityExpression(
     uint32_t line,
     XFA_FM_TOKEN op,
-    CXFA_FMSimpleExpression* pExp1,
-    CXFA_FMSimpleExpression* pExp2)
-    : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp1,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2)
+    : CXFA_FMBinExpression(line, op, std::move(pExp1), std::move(pExp2)) {}
 
 void CXFA_FMEqualityExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   switch (m_op) {
     case TOKeq:
     case TOKkseq:
       javascript << gs_lpStrExpFuncName[EQUALITY];
       break;
     case TOKne:
     case TOKksne:
       javascript << gs_lpStrExpFuncName[NOTEQUALITY];
       break;
     default:
       ASSERT(false);
       break;
   }
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMRelationalExpression::CXFA_FMRelationalExpression(
     uint32_t line,
     XFA_FM_TOKEN op,
-    CXFA_FMSimpleExpression* pExp1,
-    CXFA_FMSimpleExpression* pExp2)
-    : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp1,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2)
+    : CXFA_FMBinExpression(line, op, std::move(pExp1), std::move(pExp2)) {}
 
 void CXFA_FMRelationalExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   switch (m_op) {
     case TOKlt:
     case TOKkslt:
       javascript << gs_lpStrExpFuncName[LESS];
       break;
     case TOKgt:
     case TOKksgt:
       javascript << gs_lpStrExpFuncName[GREATER];
@@ skipping 13 matching lines @@
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMAdditiveExpression::CXFA_FMAdditiveExpression(
     uint32_t line,
     XFA_FM_TOKEN op,
-    CXFA_FMSimpleExpression* pExp1,
-    CXFA_FMSimpleExpression* pExp2)
-    : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp1,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2)
+    : CXFA_FMBinExpression(line, op, std::move(pExp1), std::move(pExp2)) {}
 
 void CXFA_FMAdditiveExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   switch (m_op) {
     case TOKplus:
       javascript << gs_lpStrExpFuncName[PLUS];
       break;
     case TOKminus:
       javascript << gs_lpStrExpFuncName[MINUS];
       break;
     default:
       ASSERT(false);
       break;
   }
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMMultiplicativeExpression::CXFA_FMMultiplicativeExpression(
     uint32_t line,
     XFA_FM_TOKEN op,
-    CXFA_FMSimpleExpression* pExp1,
-    CXFA_FMSimpleExpression* pExp2)
-    : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp1,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2)
+    : CXFA_FMBinExpression(line, op, std::move(pExp1), std::move(pExp2)) {}
 
 void CXFA_FMMultiplicativeExpression::ToJavaScript(
     CFX_WideTextBuf& javascript) {
   switch (m_op) {
     case TOKmul:
       javascript << gs_lpStrExpFuncName[MULTIPLE];
       break;
     case TOKdiv:
       javascript << gs_lpStrExpFuncName[DIVIDE];
       break;
     default:
       ASSERT(false);
       break;
   }
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
-CXFA_FMPosExpression::CXFA_FMPosExpression(uint32_t line,
-                                           CXFA_FMSimpleExpression* pExp)
-    : CXFA_FMUnaryExpression(line, TOKplus, pExp) {}
+CXFA_FMPosExpression::CXFA_FMPosExpression(
+    uint32_t line,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp)
+    : CXFA_FMUnaryExpression(line, TOKplus, std::move(pExp)) {}
 
 void CXFA_FMPosExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[POSITIVE];
   javascript << FX_WSTRC(L"(");
   m_pExp->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
-CXFA_FMNegExpression::CXFA_FMNegExpression(uint32_t line,
-                                           CXFA_FMSimpleExpression* pExp)
-    : CXFA_FMUnaryExpression(line, TOKminus, pExp) {}
+CXFA_FMNegExpression::CXFA_FMNegExpression(
+    uint32_t line,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp)
+    : CXFA_FMUnaryExpression(line, TOKminus, std::move(pExp)) {}
 
 void CXFA_FMNegExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[NEGATIVE];
   javascript << FX_WSTRC(L"(");
   m_pExp->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
-CXFA_FMNotExpression::CXFA_FMNotExpression(uint32_t line,
-                                           CXFA_FMSimpleExpression* pExp)
-    : CXFA_FMUnaryExpression(line, TOKksnot, pExp) {}
+CXFA_FMNotExpression::CXFA_FMNotExpression(
+    uint32_t line,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp)
+    : CXFA_FMUnaryExpression(line, TOKksnot, std::move(pExp)) {}
 
 void CXFA_FMNotExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[NOT];
   javascript << FX_WSTRC(L"(");
   m_pExp->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMCallExpression::CXFA_FMCallExpression(
     uint32_t line,
-    CXFA_FMSimpleExpression* pExp,
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp,
     std::vector<std::unique_ptr<CXFA_FMSimpleExpression>>&& pArguments,
     bool bIsSomMethod)
-    : CXFA_FMUnaryExpression(line, TOKcall, pExp),
+    : CXFA_FMUnaryExpression(line, TOKcall, std::move(pExp)),
       m_bIsSomMethod(bIsSomMethod),
       m_Arguments(std::move(pArguments)) {}
 
 CXFA_FMCallExpression::~CXFA_FMCallExpression() {}
 
 bool CXFA_FMCallExpression::IsBuildInFunc(CFX_WideTextBuf* funcName) {
   uint32_t uHash = FX_HashCode_GetW(funcName->AsStringC(), true);
   const XFA_FMBuildInFunc* pEnd = g_BuildInFuncs + FX_ArraySize(g_BuildInFuncs);
   const XFA_FMBuildInFunc* pFunc =
       std::lower_bound(g_BuildInFuncs, pEnd, uHash,
@@ skipping 109 matching lines @@
     }
     javascript << L")";
     if (isEvalFunc) {
       javascript << L")";
     }
   }
 }
 
 CXFA_FMDotAccessorExpression::CXFA_FMDotAccessorExpression(
     uint32_t line,
-    CXFA_FMSimpleExpression* pAccessor,
+    std::unique_ptr<CXFA_FMSimpleExpression> pAccessor,
     XFA_FM_TOKEN op,
     CFX_WideStringC wsIdentifier,
-    CXFA_FMSimpleExpression* pIndexExp)
-    : CXFA_FMBinExpression(line, op, pAccessor, pIndexExp),
+    std::unique_ptr<CXFA_FMSimpleExpression> pIndexExp)
+    : CXFA_FMBinExpression(line,
+                           op,
+                           std::move(pAccessor),
+                           std::move(pIndexExp)),
       m_wsIdentifier(wsIdentifier) {}
 
 CXFA_FMDotAccessorExpression::~CXFA_FMDotAccessorExpression() {}
 
 void CXFA_FMDotAccessorExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[DOT];
   javascript << FX_WSTRC(L"(");
   if (m_pExp1) {
     m_pExp1->ToJavaScript(javascript);
   } else {
@@ skipping 18 matching lines @@
     javascript << m_wsIdentifier;
     javascript << FX_WSTRC(L"\", ");
   }
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMIndexExpression::CXFA_FMIndexExpression(
     uint32_t line,
     XFA_FM_AccessorIndex accessorIndex,
-    CXFA_FMSimpleExpression* pIndexExp,
+    std::unique_ptr<CXFA_FMSimpleExpression> pIndexExp,
     bool bIsStarIndex)
-    : CXFA_FMUnaryExpression(line, TOKlbracket, pIndexExp),
+    : CXFA_FMUnaryExpression(line, TOKlbracket, std::move(pIndexExp)),
       m_accessorIndex(accessorIndex),
       m_bIsStarIndex(bIsStarIndex) {}
 
 void CXFA_FMIndexExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   switch (m_accessorIndex) {
     case ACCESSOR_NO_INDEX:
       javascript << FX_WSTRC(L"0");
       break;
     case ACCESSOR_NO_RELATIVEINDEX:
       javascript << FX_WSTRC(L"1");
@@ skipping 12 matching lines @@
     if (m_pExp) {
       m_pExp->ToJavaScript(javascript);
     } else {
       javascript << FX_WSTRC(L"0");
     }
   }
 }
 
 CXFA_FMDotDotAccessorExpression::CXFA_FMDotDotAccessorExpression(
     uint32_t line,
-    CXFA_FMSimpleExpression* pAccessor,
+    std::unique_ptr<CXFA_FMSimpleExpression> pAccessor,
     XFA_FM_TOKEN op,
     CFX_WideStringC wsIdentifier,
-    CXFA_FMSimpleExpression* pIndexExp)
-    : CXFA_FMBinExpression(line, op, pAccessor, pIndexExp),
+    std::unique_ptr<CXFA_FMSimpleExpression> pIndexExp)
+    : CXFA_FMBinExpression(line,
+                           op,
+                           std::move(pAccessor),
+                           std::move(pIndexExp)),
       m_wsIdentifier(wsIdentifier) {}
 
 CXFA_FMDotDotAccessorExpression::~CXFA_FMDotDotAccessorExpression() {}
 
 void CXFA_FMDotDotAccessorExpression::ToJavaScript(
     CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[DOTDOT];
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   javascript << FX_WSTRC(L"\"");
   if (m_pExp1 && m_pExp1->GetOperatorToken() == TOKidentifier) {
     m_pExp1->ToJavaScript(javascript);
   }
   javascript << FX_WSTRC(L"\", ");
   javascript << FX_WSTRC(L"\"");
   javascript << m_wsIdentifier;
   javascript << FX_WSTRC(L"\", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMMethodCallExpression::CXFA_FMMethodCallExpression(
     uint32_t line,
-    CXFA_FMSimpleExpression* pAccessorExp1,
-    CXFA_FMSimpleExpression* pCallExp)
-    : CXFA_FMBinExpression(line, TOKdot, pAccessorExp1, pCallExp) {}
+    std::unique_ptr<CXFA_FMSimpleExpression> pAccessorExp1,
+    std::unique_ptr<CXFA_FMSimpleExpression> pCallExp)
+    : CXFA_FMBinExpression(line,
+                           TOKdot,
+                           std::move(pAccessorExp1),
+                           std::move(pCallExp)) {}
 
 void CXFA_FMMethodCallExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << FX_WSTRC(L"(\nfunction ()\n{\n");
   javascript << FX_WSTRC(L"var method_return_value = null;\n");
   javascript << FX_WSTRC(L"var accessor_object = ");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L";\n");
   javascript << FX_WSTRC(L"if (");
   javascript << gs_lpStrExpFuncName[ISFMARRAY];
   javascript << FX_WSTRC(L"(accessor_object))\n{\n");
   javascript << FX_WSTRC(
       L"for(var index = accessor_object.length - 1; index > 1; index--)\n{\n");
   javascript << FX_WSTRC(L"method_return_value = accessor_object[index].");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L";\n}\n}\n");
   javascript << FX_WSTRC(L"else\n{\nmethod_return_value = accessor_object.");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L";\n}\n");
   javascript << FX_WSTRC(L"return method_return_value;\n");
   javascript << FX_WSTRC(L"}\n).call(this)");
 }