diff options
Diffstat (limited to 'xfa/fxfa')
| -rw-r--r-- | xfa/fxfa/fm2js/xfa_expression.cpp | 82 | ||||
| -rw-r--r-- | xfa/fxfa/fm2js/xfa_expression.h | 9 | ||||
| -rw-r--r-- | xfa/fxfa/fm2js/xfa_fmparse.cpp | 580 | ||||
| -rw-r--r-- | xfa/fxfa/fm2js/xfa_fmparse.h | 50 | ||||
| -rw-r--r-- | xfa/fxfa/fm2js/xfa_program.cpp | 23 | ||||
| -rw-r--r-- | xfa/fxfa/fm2js/xfa_simpleexpression.cpp | 95 | ||||
| -rw-r--r-- | xfa/fxfa/fm2js/xfa_simpleexpression.h | 12 | ||||
| -rw-r--r-- | xfa/fxfa/fm2js/xfa_simpleexpression_unittest.cpp | 12 |
8 files changed, 412 insertions, 451 deletions
diff --git a/xfa/fxfa/fm2js/xfa_expression.cpp b/xfa/fxfa/fm2js/xfa_expression.cpp index 5734593ff8..8d1888a797 100644 --- a/xfa/fxfa/fm2js/xfa_expression.cpp +++ b/xfa/fxfa/fm2js/xfa_expression.cpp @@ -35,24 +35,17 @@ CXFA_FMFunctionDefinition::CXFA_FMFunctionDefinition( bool isGlobal, const CFX_WideStringC& wsName, std::unique_ptr<CFX_WideStringCArray> pArguments, - CFX_ArrayTemplate<CXFA_FMExpression*>* pExpressions) + std::vector<std::unique_ptr<CXFA_FMExpression>>&& pExpressions) : CXFA_FMExpression(line, XFA_FM_EXPTYPE_FUNC), m_wsName(wsName), m_pArguments(std::move(pArguments)), - m_pExpressions(pExpressions), + m_pExpressions(std::move(pExpressions)), m_isGlobal(isGlobal) {} -CXFA_FMFunctionDefinition::~CXFA_FMFunctionDefinition() { - if (m_pExpressions) { - for (int i = 0; i < m_pExpressions->GetSize(); ++i) - delete m_pExpressions->GetAt(i); - - delete m_pExpressions; - } -} +CXFA_FMFunctionDefinition::~CXFA_FMFunctionDefinition() {} void CXFA_FMFunctionDefinition::ToJavaScript(CFX_WideTextBuf& javascript) { - if (m_isGlobal && (!m_pExpressions || m_pExpressions->GetSize() == 0)) { + if (m_isGlobal && m_pExpressions.empty()) { javascript << FX_WSTRC(L"// comments only"); return; } @@ -87,15 +80,11 @@ void CXFA_FMFunctionDefinition::ToJavaScript(CFX_WideTextBuf& javascript) { javascript << FX_WSTRC(L"var "); javascript << RUNTIMEFUNCTIONRETURNVALUE; javascript << FX_WSTRC(L" = null;\n"); - if (m_pExpressions) { - for (int i = 0; i < m_pExpressions->GetSize(); ++i) { - CXFA_FMExpression* e = m_pExpressions->GetAt(i); - if (i + 1 < m_pExpressions->GetSize()) { - e->ToJavaScript(javascript); - } else { - e->ToImpliedReturnJS(javascript); - } - } + for (const auto& expr : m_pExpressions) { + if (expr == m_pExpressions.back()) + expr->ToImpliedReturnJS(javascript); + else + expr->ToJavaScript(javascript); } javascript << FX_WSTRC(L"return "); if (m_isGlobal) { @@ -210,39 +199,26 @@ void CXFA_FMExpExpression::ToImpliedReturnJS(CFX_WideTextBuf& javascript) { CXFA_FMBlockExpression::CXFA_FMBlockExpression( uint32_t line, - CFX_ArrayTemplate<CXFA_FMExpression*>* pExpressionList) + std::vector<std::unique_ptr<CXFA_FMExpression>>&& pExpressionList) : CXFA_FMExpression(line, XFA_FM_EXPTYPE_BLOCK), - m_pExpressionList(pExpressionList) {} + m_ExpressionList(std::move(pExpressionList)) {} -CXFA_FMBlockExpression::~CXFA_FMBlockExpression() { - if (m_pExpressionList) { - for (int i = 0; i < m_pExpressionList->GetSize(); ++i) - delete m_pExpressionList->GetAt(i); - - delete m_pExpressionList; - } -} +CXFA_FMBlockExpression::~CXFA_FMBlockExpression() {} void CXFA_FMBlockExpression::ToJavaScript(CFX_WideTextBuf& javascript) { javascript << FX_WSTRC(L"{\n"); - if (m_pExpressionList) { - for (int i = 0; i < m_pExpressionList->GetSize(); ++i) - m_pExpressionList->GetAt(i)->ToJavaScript(javascript); - } + for (const auto& expr : m_ExpressionList) + expr->ToJavaScript(javascript); javascript << FX_WSTRC(L"}\n"); } void CXFA_FMBlockExpression::ToImpliedReturnJS(CFX_WideTextBuf& javascript) { javascript << FX_WSTRC(L"{\n"); - if (m_pExpressionList) { - for (int i = 0; i < m_pExpressionList->GetSize(); ++i) { - CXFA_FMExpression* e = m_pExpressionList->GetAt(i); - if (i + 1 == m_pExpressionList->GetSize()) { - e->ToImpliedReturnJS(javascript); - } else { - e->ToJavaScript(javascript); - } - } + for (const auto& expr : m_ExpressionList) { + if (expr == m_ExpressionList.back()) + expr->ToImpliedReturnJS(javascript); + else + expr->ToJavaScript(javascript); } javascript << FX_WSTRC(L"}\n"); } @@ -536,12 +512,10 @@ void CXFA_FMForeachExpression::ToJavaScript(CFX_WideTextBuf& javascript) { javascript << XFA_FM_EXPTypeToString(CONCATFMOBJECT); javascript << FX_WSTRC(L"("); - for (size_t i = 0; i < m_pAccessors.size(); ++i) { - CXFA_FMSimpleExpression* s = m_pAccessors.at(i).get(); - s->ToJavaScript(javascript); - if (i + 1 < m_pAccessors.size()) { - javascript << FX_WSTRC(L", "); - } + for (const auto& expr : m_pAccessors) { + expr->ToJavaScript(javascript); + if (expr != m_pAccessors.back()) + javascript << L", "; } javascript << FX_WSTRC(L");\n"); javascript << FX_WSTRC(L"var "); @@ -587,12 +561,10 @@ void CXFA_FMForeachExpression::ToImpliedReturnJS(CFX_WideTextBuf& javascript) { javascript << FX_WSTRC(L" = "); javascript << XFA_FM_EXPTypeToString(CONCATFMOBJECT); javascript << FX_WSTRC(L"("); - for (size_t i = 0; i < m_pAccessors.size(); ++i) { - CXFA_FMSimpleExpression* s = m_pAccessors.at(i).get(); - s->ToJavaScript(javascript); - if (i + 1 < m_pAccessors.size()) { - javascript << FX_WSTRC(L", "); - } + for (const auto& expr : m_pAccessors) { + expr->ToJavaScript(javascript); + if (expr != m_pAccessors.back()) + javascript << L", "; } javascript << FX_WSTRC(L");\n"); javascript << FX_WSTRC(L"var "); diff --git a/xfa/fxfa/fm2js/xfa_expression.h b/xfa/fxfa/fm2js/xfa_expression.h index 236b51a6b0..f89a923565 100644 --- a/xfa/fxfa/fm2js/xfa_expression.h +++ b/xfa/fxfa/fm2js/xfa_expression.h @@ -46,7 +46,7 @@ class CXFA_FMFunctionDefinition : public CXFA_FMExpression { bool isGlobal, const CFX_WideStringC& wsName, std::unique_ptr<CFX_WideStringCArray> pArguments, - CFX_ArrayTemplate<CXFA_FMExpression*>* pExpressions); + std::vector<std::unique_ptr<CXFA_FMExpression>>&& pExpressions); ~CXFA_FMFunctionDefinition() override; void ToJavaScript(CFX_WideTextBuf& javascript) override; @@ -55,7 +55,7 @@ class CXFA_FMFunctionDefinition : public CXFA_FMExpression { private: CFX_WideStringC m_wsName; std::unique_ptr<CFX_WideStringCArray> m_pArguments; - CFX_ArrayTemplate<CXFA_FMExpression*>* m_pExpressions; + std::vector<std::unique_ptr<CXFA_FMExpression>> m_pExpressions; bool m_isGlobal; }; @@ -88,17 +88,16 @@ class CXFA_FMExpExpression : public CXFA_FMExpression { class CXFA_FMBlockExpression : public CXFA_FMExpression { public: - // Takes ownership of |pExpressionList|. CXFA_FMBlockExpression( uint32_t line, - CFX_ArrayTemplate<CXFA_FMExpression*>* pExpressionList); + std::vector<std::unique_ptr<CXFA_FMExpression>>&& pExpressionList); ~CXFA_FMBlockExpression() override; void ToJavaScript(CFX_WideTextBuf& javascript) override; void ToImpliedReturnJS(CFX_WideTextBuf&) override; private: - CFX_ArrayTemplate<CXFA_FMExpression*>* m_pExpressionList; + std::vector<std::unique_ptr<CXFA_FMExpression>> m_ExpressionList; }; class CXFA_FMDoExpression : public CXFA_FMExpression { diff --git a/xfa/fxfa/fm2js/xfa_fmparse.cpp b/xfa/fxfa/fm2js/xfa_fmparse.cpp index 36663fce2d..07edc32c3d 100644 --- a/xfa/fxfa/fm2js/xfa_fmparse.cpp +++ b/xfa/fxfa/fm2js/xfa_fmparse.cpp @@ -19,7 +19,7 @@ CXFA_FMParse::~CXFA_FMParse() {} int32_t CXFA_FMParse::Init(const CFX_WideStringC& wsFormcalc, CXFA_FMErrorInfo* pErrorInfo) { m_pErrorInfo = pErrorInfo; - m_lexer.reset(new CXFA_FMLexer(wsFormcalc, m_pErrorInfo)); + m_lexer = pdfium::MakeUnique<CXFA_FMLexer>(wsFormcalc, m_pErrorInfo); return 0; } @@ -50,41 +50,41 @@ void CXFA_FMParse::Error(uint32_t lineNum, const FX_WCHAR* msg, ...) { va_end(ap); } -CFX_ArrayTemplate<CXFA_FMExpression*>* CXFA_FMParse::ParseTopExpression() { - std::unique_ptr<CXFA_FMExpression> e; - CFX_ArrayTemplate<CXFA_FMExpression*>* expression = - new CFX_ArrayTemplate<CXFA_FMExpression*>(); +std::vector<std::unique_ptr<CXFA_FMExpression>> +CXFA_FMParse::ParseTopExpression() { + std::unique_ptr<CXFA_FMExpression> expr; + std::vector<std::unique_ptr<CXFA_FMExpression>> expressions; while (1) { if (m_pToken->m_type == TOKeof || m_pToken->m_type == TOKendfunc || m_pToken->m_type == TOKendif || m_pToken->m_type == TOKelseif || m_pToken->m_type == TOKelse || m_pToken->m_type == TOKreserver) { - return expression; + return expressions; } if (m_pToken->m_type == TOKfunc) { - e.reset(ParseFunction()); - if (e) { - expression->Add(e.release()); + expr = ParseFunction(); + if (expr) { + expressions.push_back(std::move(expr)); } else { break; } } else { - e.reset(ParseExpression()); - if (e) { - expression->Add(e.release()); + expr = ParseExpression(); + if (expr) { + expressions.push_back(std::move(expr)); } else { break; } } } - return expression; + return expressions; } -CXFA_FMExpression* CXFA_FMParse::ParseFunction() { - std::unique_ptr<CXFA_FMExpression> e; +std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseFunction() { + std::unique_ptr<CXFA_FMExpression> expr; CFX_WideStringC ident; std::unique_ptr<CFX_WideStringCArray> pArguments; - std::unique_ptr<CFX_ArrayTemplate<CXFA_FMExpression*>> pExpressions; + std::vector<std::unique_ptr<CXFA_FMExpression>> expressions; uint32_t line = m_pToken->m_uLinenum; NextToken(); if (m_pToken->m_type != TOKidentifier) { @@ -99,7 +99,7 @@ CXFA_FMExpression* CXFA_FMParse::ParseFunction() { if (m_pToken->m_type == TOKrparen) { NextToken(); } else { - pArguments.reset(new CFX_WideStringCArray()); + pArguments = pdfium::MakeUnique<CFX_WideStringCArray>(); CFX_WideStringC p; while (1) { if (m_pToken->m_type == TOKidentifier) { @@ -129,29 +129,24 @@ CXFA_FMExpression* CXFA_FMParse::ParseFunction() { if (m_pToken->m_type == TOKendfunc) { NextToken(); } else { - pExpressions.reset(ParseTopExpression()); + expressions = ParseTopExpression(); Check(TOKendfunc); } if (m_pErrorInfo->message.IsEmpty()) { - e.reset(new CXFA_FMFunctionDefinition(line, 0, ident, std::move(pArguments), - pExpressions.release())); - } else { - if (pArguments) - pArguments->RemoveAll(); - if (pExpressions) { - for (int i = 0; i < pExpressions->GetSize(); ++i) - delete pExpressions->GetAt(i); - } + expr = pdfium::MakeUnique<CXFA_FMFunctionDefinition>( + line, false, ident, std::move(pArguments), std::move(expressions)); + } else if (pArguments) { + pArguments->RemoveAll(); } - return e.release(); + return expr; } -CXFA_FMExpression* CXFA_FMParse::ParseExpression() { - std::unique_ptr<CXFA_FMExpression> e; +std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseExpression() { + std::unique_ptr<CXFA_FMExpression> expr; uint32_t line = m_pToken->m_uLinenum; switch (m_pToken->m_type) { case TOKvar: - e.reset(ParseVarExpression()); + expr = ParseVarExpression(); break; case TOKnull: case TOKnumber: @@ -161,29 +156,29 @@ CXFA_FMExpression* CXFA_FMParse::ParseExpression() { case TOKksnot: case TOKidentifier: case TOKlparen: - e.reset(ParseExpExpression()); + expr = ParseExpExpression(); break; case TOKif: - e.reset(ParseIfExpression()); + expr = ParseIfExpression(); break; case TOKwhile: - e.reset(ParseWhileExpression()); + expr = ParseWhileExpression(); break; case TOKfor: - e.reset(ParseForExpression()); + expr = ParseForExpression(); break; case TOKforeach: - e.reset(ParseForeachExpression()); + expr = ParseForeachExpression(); break; case TOKdo: - e.reset(ParseDoExpression()); + expr = ParseDoExpression(); break; case TOKbreak: - e.reset(new CXFA_FMBreakExpression(line)); + expr = pdfium::MakeUnique<CXFA_FMBreakExpression>(line); NextToken(); break; case TOKcontinue: - e.reset(new CXFA_FMContinueExpression(line)); + expr = pdfium::MakeUnique<CXFA_FMContinueExpression>(line); NextToken(); break; default: @@ -193,11 +188,11 @@ CXFA_FMExpression* CXFA_FMParse::ParseExpression() { NextToken(); break; } - return e.release(); + return expr; } -CXFA_FMExpression* CXFA_FMParse::ParseVarExpression() { - std::unique_ptr<CXFA_FMExpression> e; +std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseVarExpression() { + std::unique_ptr<CXFA_FMExpression> expr; CFX_WideStringC ident; uint32_t line = m_pToken->m_uLinenum; NextToken(); @@ -211,47 +206,49 @@ CXFA_FMExpression* CXFA_FMParse::ParseVarExpression() { } if (m_pToken->m_type == TOKassign) { NextToken(); - e.reset(ParseExpExpression()); + expr = ParseExpExpression(); } if (m_pErrorInfo->message.IsEmpty()) { - e.reset(new CXFA_FMVarExpression(line, ident, e.release())); + expr = + pdfium::MakeUnique<CXFA_FMVarExpression>(line, ident, expr.release()); } else { - e.reset(); + expr.reset(); } - return e.release(); + return expr; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParseSimpleExpression() { +std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseSimpleExpression() { uint32_t line = m_pToken->m_uLinenum; - std::unique_ptr<CXFA_FMSimpleExpression> pExp1(ParseLogicalOrExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression(); while (m_pToken->m_type == TOKassign) { NextToken(); - std::unique_ptr<CXFA_FMSimpleExpression> pExp2(ParseLogicalOrExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> pExp2 = ParseLogicalOrExpression(); if (m_pErrorInfo->message.IsEmpty()) { - pExp1.reset(new CXFA_FMAssignExpression(line, TOKassign, pExp1.release(), - pExp2.release())); + pExp1 = pdfium::MakeUnique<CXFA_FMAssignExpression>( + line, TOKassign, pExp1.release(), pExp2.release()); } else { pExp1.reset(); } } - return pExp1.release(); + return pExp1; } -CXFA_FMExpression* CXFA_FMParse::ParseExpExpression() { +std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseExpExpression() { uint32_t line = m_pToken->m_uLinenum; - std::unique_ptr<CXFA_FMSimpleExpression> pExp1(ParseSimpleExpression()); - std::unique_ptr<CXFA_FMExpression> e; + std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseSimpleExpression(); + std::unique_ptr<CXFA_FMExpression> expr; if (m_pErrorInfo->message.IsEmpty()) { - e.reset(new CXFA_FMExpExpression(line, pExp1.release())); + expr = pdfium::MakeUnique<CXFA_FMExpExpression>(line, pExp1.release()); } else { - e.reset(); + expr.reset(); } - return e.release(); + return expr; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalOrExpression() { +std::unique_ptr<CXFA_FMSimpleExpression> +CXFA_FMParse::ParseLogicalOrExpression() { uint32_t line = m_pToken->m_uLinenum; - std::unique_ptr<CXFA_FMSimpleExpression> e1(ParseLogicalAndExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseLogicalAndExpression(); for (;;) { switch (m_pToken->m_type) { case TOKor: @@ -260,8 +257,8 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalOrExpression() { std::unique_ptr<CXFA_FMSimpleExpression> e2( ParseLogicalAndExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMLogicalOrExpression(line, TOKor, e1.release(), - e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMLogicalOrExpression>( + line, TOKor, e1.release(), e2.release()); } else { e1.reset(); } @@ -272,21 +269,22 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalOrExpression() { } break; } - return e1.release(); + return e1; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalAndExpression() { +std::unique_ptr<CXFA_FMSimpleExpression> +CXFA_FMParse::ParseLogicalAndExpression() { uint32_t line = m_pToken->m_uLinenum; - std::unique_ptr<CXFA_FMSimpleExpression> e1(ParseEqualityExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseEqualityExpression(); for (;;) { switch (m_pToken->m_type) { case TOKand: case TOKksand: { NextToken(); - std::unique_ptr<CXFA_FMSimpleExpression> e2(ParseEqualityExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> e2 = ParseEqualityExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMLogicalAndExpression(line, TOKand, e1.release(), - e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMLogicalAndExpression>( + line, TOKand, e1.release(), e2.release()); } else { e1.reset(); } @@ -297,22 +295,23 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalAndExpression() { } break; } - return e1.release(); + return e1; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParseEqualityExpression() { +std::unique_ptr<CXFA_FMSimpleExpression> +CXFA_FMParse::ParseEqualityExpression() { uint32_t line = m_pToken->m_uLinenum; - std::unique_ptr<CXFA_FMSimpleExpression> e1(ParseRelationalExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseRelationalExpression(); for (;;) { std::unique_ptr<CXFA_FMSimpleExpression> e2; switch (m_pToken->m_type) { case TOKeq: case TOKkseq: NextToken(); - e2.reset(ParseRelationalExpression()); + e2 = ParseRelationalExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMEqualityExpression(line, TOKeq, e1.release(), - e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMEqualityExpression>( + line, TOKeq, e1.release(), e2.release()); } else { e1.reset(); } @@ -320,10 +319,10 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseEqualityExpression() { case TOKne: case TOKksne: NextToken(); - e2.reset(ParseRelationalExpression()); + e2 = ParseRelationalExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMEqualityExpression(line, TOKne, e1.release(), - e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMEqualityExpression>( + line, TOKne, e1.release(), e2.release()); } else { e1.reset(); } @@ -333,22 +332,23 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseEqualityExpression() { } break; } - return e1.release(); + return e1; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParseRelationalExpression() { +std::unique_ptr<CXFA_FMSimpleExpression> +CXFA_FMParse::ParseRelationalExpression() { uint32_t line = m_pToken->m_uLinenum; - std::unique_ptr<CXFA_FMSimpleExpression> e1(ParseAddtiveExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseAddtiveExpression(); for (;;) { std::unique_ptr<CXFA_FMSimpleExpression> e2; switch (m_pToken->m_type) { case TOKlt: case TOKkslt: NextToken(); - e2.reset(ParseAddtiveExpression()); + e2 = ParseAddtiveExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMRelationalExpression(line, TOKlt, e1.release(), - e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( + line, TOKlt, e1.release(), e2.release()); } else { e1.reset(); } @@ -356,10 +356,10 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseRelationalExpression() { case TOKgt: case TOKksgt: NextToken(); - e2.reset(ParseAddtiveExpression()); + e2 = ParseAddtiveExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMRelationalExpression(line, TOKgt, e1.release(), - e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( + line, TOKgt, e1.release(), e2.release()); } else { e1.reset(); } @@ -367,10 +367,10 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseRelationalExpression() { case TOKle: case TOKksle: NextToken(); - e2.reset(ParseAddtiveExpression()); + e2 = ParseAddtiveExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMRelationalExpression(line, TOKle, e1.release(), - e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( + line, TOKle, e1.release(), e2.release()); } else { e1.reset(); } @@ -378,10 +378,10 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseRelationalExpression() { case TOKge: case TOKksge: NextToken(); - e2.reset(ParseAddtiveExpression()); + e2 = ParseAddtiveExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMRelationalExpression(line, TOKge, e1.release(), - e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( + line, TOKge, e1.release(), e2.release()); } else { e1.reset(); } @@ -391,31 +391,32 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseRelationalExpression() { } break; } - return e1.release(); + return e1; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParseAddtiveExpression() { +std::unique_ptr<CXFA_FMSimpleExpression> +CXFA_FMParse::ParseAddtiveExpression() { uint32_t line = m_pToken->m_uLinenum; - std::unique_ptr<CXFA_FMSimpleExpression> e1(ParseMultiplicativeExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseMultiplicativeExpression(); for (;;) { std::unique_ptr<CXFA_FMSimpleExpression> e2; switch (m_pToken->m_type) { case TOKplus: NextToken(); - e2.reset(ParseMultiplicativeExpression()); + e2 = ParseMultiplicativeExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMAdditiveExpression(line, TOKplus, e1.release(), - e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMAdditiveExpression>( + line, TOKplus, e1.release(), e2.release()); } else { e1.reset(); } continue; case TOKminus: NextToken(); - e2.reset(ParseMultiplicativeExpression()); + e2 = ParseMultiplicativeExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMAdditiveExpression(line, TOKminus, e1.release(), - e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMAdditiveExpression>( + line, TOKminus, e1.release(), e2.release()); } else { e1.reset(); } @@ -425,31 +426,32 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseAddtiveExpression() { } break; } - return e1.release(); + return e1; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParseMultiplicativeExpression() { +std::unique_ptr<CXFA_FMSimpleExpression> +CXFA_FMParse::ParseMultiplicativeExpression() { uint32_t line = m_pToken->m_uLinenum; - std::unique_ptr<CXFA_FMSimpleExpression> e1(ParseUnaryExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseUnaryExpression(); for (;;) { std::unique_ptr<CXFA_FMSimpleExpression> e2; switch (m_pToken->m_type) { case TOKmul: NextToken(); - e2.reset(ParseUnaryExpression()); + e2 = ParseUnaryExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMMultiplicativeExpression( - line, TOKmul, e1.release(), e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMMultiplicativeExpression>( + line, TOKmul, e1.release(), e2.release()); } else { e1.reset(); } continue; case TOKdiv: NextToken(); - e2.reset(ParseUnaryExpression()); + e2 = ParseUnaryExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e1.reset(new CXFA_FMMultiplicativeExpression( - line, TOKdiv, e1.release(), e2.release())); + e1 = pdfium::MakeUnique<CXFA_FMMultiplicativeExpression>( + line, TOKdiv, e1.release(), e2.release()); } else { e1.reset(); } @@ -459,83 +461,88 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseMultiplicativeExpression() { } break; } - return e1.release(); + return e1; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParseUnaryExpression() { - std::unique_ptr<CXFA_FMSimpleExpression> e; +std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseUnaryExpression() { + std::unique_ptr<CXFA_FMSimpleExpression> expr; uint32_t line = m_pToken->m_uLinenum; switch (m_pToken->m_type) { case TOKplus: NextToken(); - e.reset(ParseUnaryExpression()); + expr = ParseUnaryExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e.reset(new CXFA_FMPosExpression(line, e.release())); + expr = pdfium::MakeUnique<CXFA_FMPosExpression>(line, expr.release()); } else { - e.reset(); + expr.reset(); } break; case TOKminus: NextToken(); - e.reset(ParseUnaryExpression()); + expr = ParseUnaryExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e.reset(new CXFA_FMNegExpression(line, e.release())); + expr = pdfium::MakeUnique<CXFA_FMNegExpression>(line, expr.release()); } else { - e.reset(); + expr.reset(); } break; case TOKksnot: NextToken(); - e.reset(ParseUnaryExpression()); + expr = ParseUnaryExpression(); if (m_pErrorInfo->message.IsEmpty()) { - e.reset(new CXFA_FMNotExpression(line, e.release())); + expr = pdfium::MakeUnique<CXFA_FMNotExpression>(line, expr.release()); } else { - e.reset(); + expr.reset(); } break; default: - e.reset(ParsePrimaryExpression()); + expr = ParsePrimaryExpression(); break; } - return e.release(); + return expr; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParsePrimaryExpression() { - std::unique_ptr<CXFA_FMSimpleExpression> e; +std::unique_ptr<CXFA_FMSimpleExpression> +CXFA_FMParse::ParsePrimaryExpression() { + std::unique_ptr<CXFA_FMSimpleExpression> expr; uint32_t line = m_pToken->m_uLinenum; switch (m_pToken->m_type) { case TOKnumber: - e.reset(new CXFA_FMNumberExpression(line, m_pToken->m_wstring)); + expr = pdfium::MakeUnique<CXFA_FMNumberExpression>(line, + m_pToken->m_wstring); NextToken(); break; case TOKstring: - e.reset(new CXFA_FMStringExpression(line, m_pToken->m_wstring)); + expr = pdfium::MakeUnique<CXFA_FMStringExpression>(line, + m_pToken->m_wstring); NextToken(); break; case TOKidentifier: { CFX_WideStringC wsIdentifier(m_pToken->m_wstring); NextToken(); if (m_pToken->m_type == TOKlbracket) { - CXFA_FMSimpleExpression* s = ParseIndexExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); if (s) { - e.reset(new CXFA_FMDotAccessorExpression(line, nullptr, TOKdot, - wsIdentifier, s)); + expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( + line, nullptr, TOKdot, wsIdentifier, s.release()); } NextToken(); } else { - e.reset(new CXFA_FMIdentifierExpression(line, wsIdentifier)); + expr = + pdfium::MakeUnique<CXFA_FMIdentifierExpression>(line, wsIdentifier); } } break; case TOKif: - e.reset(new CXFA_FMIdentifierExpression(line, m_pToken->m_wstring)); + expr = pdfium::MakeUnique<CXFA_FMIdentifierExpression>( + line, m_pToken->m_wstring); NextToken(); break; case TOKnull: - e.reset(new CXFA_FMNullExpression(line)); + expr = pdfium::MakeUnique<CXFA_FMNullExpression>(line); NextToken(); break; case TOKlparen: - e.reset(ParseParenExpression()); + expr = ParseParenExpression(); break; default: CFX_WideString ws_TempString(m_pToken->m_wstring); @@ -544,25 +551,25 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePrimaryExpression() { NextToken(); break; } - e.reset(ParsePostExpression(e.release())); + expr = ParsePostExpression(std::move(expr)); if (!(m_pErrorInfo->message.IsEmpty())) - e.reset(); - return e.release(); + expr.reset(); + return expr; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( - CXFA_FMSimpleExpression* e) { +std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParsePostExpression( + std::unique_ptr<CXFA_FMSimpleExpression> expr) { uint32_t line = m_pToken->m_uLinenum; while (1) { switch (m_pToken->m_type) { case TOKlparen: { NextToken(); - std::unique_ptr<CFX_ArrayTemplate<CXFA_FMSimpleExpression*>> pArray; + std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> expressions; if (m_pToken->m_type != TOKrparen) { - pArray.reset(new CFX_ArrayTemplate<CXFA_FMSimpleExpression*>()); while (m_pToken->m_type != TOKrparen) { - if (CXFA_FMSimpleExpression* expr = ParseSimpleExpression()) - pArray->Add(expr); + if (std::unique_ptr<CXFA_FMSimpleExpression> expr = + ParseSimpleExpression()) + expressions.push_back(std::move(expr)); if (m_pToken->m_type == TOKcomma) { NextToken(); } else if (m_pToken->m_type == TOKeof || @@ -577,26 +584,21 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( } } if (m_pErrorInfo->message.IsEmpty()) { - e = new CXFA_FMCallExpression(line, e, pArray.release(), false); + expr = pdfium::MakeUnique<CXFA_FMCallExpression>( + line, expr.release(), std::move(expressions), false); NextToken(); - if (m_pToken->m_type != TOKlbracket) { + if (m_pToken->m_type != TOKlbracket) continue; - } - CXFA_FMSimpleExpression* s = ParseIndexExpression(); + + std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); if (s) { - e = new CXFA_FMDotAccessorExpression(line, e, TOKcall, - FX_WSTRC(L""), s); + expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( + line, expr.release(), TOKcall, FX_WSTRC(L""), s.release()); } else { - delete e; - e = nullptr; + expr.reset(); } } else { - if (pArray) { - for (int32_t i = 0; i < pArray->GetSize(); ++i) - delete pArray->GetAt(i); - } - delete e; - e = nullptr; + expr.reset(); } } break; case TOKdot: @@ -606,16 +608,14 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( uint32_t tempLine = m_pToken->m_uLinenum; NextToken(); if (m_pToken->m_type == TOKlparen) { - CXFA_FMSimpleExpression* pExpAccessor; - CXFA_FMSimpleExpression* pExpCall; - pExpAccessor = e; + std::unique_ptr<CXFA_FMSimpleExpression> pExpCall; NextToken(); - std::unique_ptr<CFX_ArrayTemplate<CXFA_FMSimpleExpression*>> pArray; + std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> expressions; if (m_pToken->m_type != TOKrparen) { - pArray.reset(new CFX_ArrayTemplate<CXFA_FMSimpleExpression*>()); while (m_pToken->m_type != TOKrparen) { - CXFA_FMSimpleExpression* exp = ParseSimpleExpression(); - pArray->Add(exp); + std::unique_ptr<CXFA_FMSimpleExpression> exp = + ParseSimpleExpression(); + expressions.push_back(std::move(exp)); if (m_pToken->m_type == TOKcomma) { NextToken(); } else if (m_pToken->m_type == TOKeof || @@ -630,50 +630,48 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( } } if (m_pErrorInfo->message.IsEmpty()) { - CXFA_FMSimpleExpression* pIdentifier = - new CXFA_FMIdentifierExpression(tempLine, tempStr); - pExpCall = new CXFA_FMCallExpression(line, pIdentifier, - pArray.release(), true); - e = new CXFA_FMMethodCallExpression(line, pExpAccessor, pExpCall); + std::unique_ptr<CXFA_FMSimpleExpression> pIdentifier = + pdfium::MakeUnique<CXFA_FMIdentifierExpression>(tempLine, + tempStr); + pExpCall = pdfium::MakeUnique<CXFA_FMCallExpression>( + line, pIdentifier.release(), std::move(expressions), true); + expr = pdfium::MakeUnique<CXFA_FMMethodCallExpression>( + line, expr.release(), pExpCall.release()); NextToken(); - if (m_pToken->m_type != TOKlbracket) { + if (m_pToken->m_type != TOKlbracket) continue; - } - CXFA_FMSimpleExpression* s = ParseIndexExpression(); + + std::unique_ptr<CXFA_FMSimpleExpression> s = + ParseIndexExpression(); if (s) { - e = new CXFA_FMDotAccessorExpression(line, e, TOKcall, - FX_WSTRC(L""), s); + expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( + line, expr.release(), TOKcall, FX_WSTRC(L""), s.release()); } else { - delete e; - e = nullptr; + expr.reset(); } } else { - if (pArray) { - for (int32_t i = 0; i < pArray->GetSize(); ++i) - delete pArray->GetAt(i); - } - delete e; - e = nullptr; + expr.reset(); } } else if (m_pToken->m_type == TOKlbracket) { - std::unique_ptr<CXFA_FMSimpleExpression> s(ParseIndexExpression()); - if (!(m_pErrorInfo->message.IsEmpty())) { - delete e; + std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); + if (!(m_pErrorInfo->message.IsEmpty())) return nullptr; - } - e = new CXFA_FMDotAccessorExpression(tempLine, e, TOKdot, tempStr, - s.release()); + + expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( + tempLine, expr.release(), TOKdot, tempStr, s.release()); } else { - CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression( - tempLine, ACCESSOR_NO_INDEX, nullptr, false); - e = new CXFA_FMDotAccessorExpression(line, e, TOKdot, tempStr, s); + std::unique_ptr<CXFA_FMSimpleExpression> s = + pdfium::MakeUnique<CXFA_FMIndexExpression>( + tempLine, ACCESSOR_NO_INDEX, nullptr, false); + expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( + line, expr.release(), TOKdot, tempStr, s.release()); continue; } } else { CFX_WideString ws_TempString(m_pToken->m_wstring); Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier, ws_TempString.c_str()); - return e; + return expr; } break; case TOKdotdot: @@ -683,25 +681,25 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( uint32_t tempLine = m_pToken->m_uLinenum; NextToken(); if (m_pToken->m_type == TOKlbracket) { - std::unique_ptr<CXFA_FMSimpleExpression> s(ParseIndexExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); if (!(m_pErrorInfo->message.IsEmpty())) { - delete e; return nullptr; } - e = new CXFA_FMDotDotAccessorExpression(tempLine, e, TOKdotdot, - tempStr, s.release()); + expr = pdfium::MakeUnique<CXFA_FMDotDotAccessorExpression>( + tempLine, expr.release(), TOKdotdot, tempStr, s.release()); } else { - CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression( - tempLine, ACCESSOR_NO_INDEX, nullptr, false); - e = new CXFA_FMDotDotAccessorExpression(line, e, TOKdotdot, tempStr, - s); + std::unique_ptr<CXFA_FMSimpleExpression> s = + pdfium::MakeUnique<CXFA_FMIndexExpression>( + tempLine, ACCESSOR_NO_INDEX, nullptr, false); + expr = pdfium::MakeUnique<CXFA_FMDotDotAccessorExpression>( + line, expr.release(), TOKdotdot, tempStr, s.release()); continue; } } else { CFX_WideString ws_TempString(m_pToken->m_wstring); Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier, ws_TempString.c_str()); - return e; + return expr; } break; case TOKdotscream: @@ -711,50 +709,51 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( uint32_t tempLine = m_pToken->m_uLinenum; NextToken(); if (m_pToken->m_type == TOKlbracket) { - std::unique_ptr<CXFA_FMSimpleExpression> s(ParseIndexExpression()); - if (!(m_pErrorInfo->message.IsEmpty())) { - delete e; + std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); + if (!(m_pErrorInfo->message.IsEmpty())) return nullptr; - } - e = new CXFA_FMDotAccessorExpression(tempLine, e, TOKdotscream, - tempStr, s.release()); + + expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( + tempLine, expr.release(), TOKdotscream, tempStr, s.release()); } else { - CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression( - tempLine, ACCESSOR_NO_INDEX, nullptr, false); - e = new CXFA_FMDotAccessorExpression(line, e, TOKdotscream, tempStr, - s); + std::unique_ptr<CXFA_FMSimpleExpression> s = + pdfium::MakeUnique<CXFA_FMIndexExpression>( + tempLine, ACCESSOR_NO_INDEX, nullptr, false); + expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( + line, expr.release(), TOKdotscream, tempStr, s.release()); continue; } } else { CFX_WideString ws_TempString(m_pToken->m_wstring); Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier, ws_TempString.c_str()); - return e; + return expr; } break; case TOKdotstar: { - CXFA_FMSimpleExpression* s = - new CXFA_FMIndexExpression(line, ACCESSOR_NO_INDEX, nullptr, false); - e = new CXFA_FMDotAccessorExpression(line, e, TOKdotstar, - FX_WSTRC(L"*"), s); + std::unique_ptr<CXFA_FMSimpleExpression> s = + pdfium::MakeUnique<CXFA_FMIndexExpression>(line, ACCESSOR_NO_INDEX, + nullptr, false); + expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( + line, expr.release(), TOKdotstar, FX_WSTRC(L"*"), s.release()); } break; default: - return e; + return expr; } NextToken(); } - return e; + return expr; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParseIndexExpression() { +std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseIndexExpression() { std::unique_ptr<CXFA_FMSimpleExpression> pExp; uint32_t line = m_pToken->m_uLinenum; NextToken(); std::unique_ptr<CXFA_FMSimpleExpression> s; XFA_FM_AccessorIndex accessorIndex = ACCESSOR_NO_RELATIVEINDEX; if (m_pToken->m_type == TOKmul) { - pExp.reset( - new CXFA_FMIndexExpression(line, accessorIndex, s.release(), true)); + pExp = pdfium::MakeUnique<CXFA_FMIndexExpression>(line, accessorIndex, + s.release(), true); NextToken(); if (m_pToken->m_type != TOKrbracket) { CFX_WideString ws_TempString(m_pToken->m_wstring); @@ -762,7 +761,7 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseIndexExpression() { XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); pExp.reset(); } - return pExp.release(); + return pExp; } if (m_pToken->m_type == TOKplus) { accessorIndex = ACCESSOR_POSITIVE_INDEX; @@ -771,19 +770,19 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseIndexExpression() { accessorIndex = ACCESSOR_NEGATIVE_INDEX; NextToken(); } - s.reset(ParseSimpleExpression()); + s = ParseSimpleExpression(); if (m_pToken->m_type != TOKrbracket) { CFX_WideString ws_TempString(m_pToken->m_wstring); Error(m_pToken->m_uLinenum, kFMErrExpectedToken, XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); } else { - pExp.reset( - new CXFA_FMIndexExpression(line, accessorIndex, s.release(), false)); + pExp = pdfium::MakeUnique<CXFA_FMIndexExpression>(line, accessorIndex, + s.release(), false); } - return pExp.release(); + return pExp; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParseParenExpression() { +std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseParenExpression() { Check(TOKlparen); if (m_pToken->m_type == TOKrparen) { @@ -793,27 +792,26 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseParenExpression() { } uint32_t line = m_pToken->m_uLinenum; - std::unique_ptr<CXFA_FMSimpleExpression> pExp1(ParseLogicalOrExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression(); while (m_pToken->m_type == TOKassign) { NextToken(); - std::unique_ptr<CXFA_FMSimpleExpression> pExp2(ParseLogicalOrExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> pExp2 = ParseLogicalOrExpression(); if (m_pErrorInfo->message.IsEmpty()) { - pExp1.reset(new CXFA_FMAssignExpression(line, TOKassign, pExp1.release(), - pExp2.release())); + pExp1 = pdfium::MakeUnique<CXFA_FMAssignExpression>( + line, TOKassign, pExp1.release(), pExp2.release()); } else { pExp1.reset(); } } Check(TOKrparen); - return pExp1.release(); + return pExp1; } -CXFA_FMExpression* CXFA_FMParse::ParseBlockExpression() { +std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseBlockExpression() { uint32_t line = m_pToken->m_uLinenum; - CXFA_FMExpression* e = nullptr; - std::unique_ptr<CFX_ArrayTemplate<CXFA_FMExpression*>> expression( - new CFX_ArrayTemplate<CXFA_FMExpression*>()); + std::unique_ptr<CXFA_FMExpression> expr; + std::vector<std::unique_ptr<CXFA_FMExpression>> expressions; while (1) { switch (m_pToken->m_type) { @@ -828,15 +826,15 @@ CXFA_FMExpression* CXFA_FMParse::ParseBlockExpression() { case TOKreserver: break; case TOKfunc: - e = ParseFunction(); - if (e) { - expression->Add(e); + expr = ParseFunction(); + if (expr) { + expressions.push_back(std::move(expr)); } continue; default: - e = ParseExpression(); - if (e) { - expression->Add(e); + expr = ParseExpression(); + if (expr) { + expressions.push_back(std::move(expr)); } continue; } @@ -844,22 +842,20 @@ CXFA_FMExpression* CXFA_FMParse::ParseBlockExpression() { } std::unique_ptr<CXFA_FMBlockExpression> pExp; if (m_pErrorInfo->message.IsEmpty()) { - pExp.reset(new CXFA_FMBlockExpression(line, expression.release())); - } else { - for (int i = 0; i < expression->GetSize(); ++i) - delete static_cast<CXFA_FMExpression*>(expression->GetAt(i)); + pExp = pdfium::MakeUnique<CXFA_FMBlockExpression>(line, + std::move(expressions)); } - return pExp.release(); + return pExp; } -CXFA_FMExpression* CXFA_FMParse::ParseIfExpression() { +std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseIfExpression() { uint32_t line = m_pToken->m_uLinenum; const FX_WCHAR* pStartPos = m_lexer->SavePos(); NextToken(); Check(TOKlparen); std::unique_ptr<CXFA_FMSimpleExpression> pExpression; while (m_pToken->m_type != TOKrparen) { - pExpression.reset(ParseSimpleExpression()); + pExpression = ParseSimpleExpression(); if (m_pToken->m_type != TOKcomma) break; NextToken(); @@ -875,7 +871,7 @@ CXFA_FMExpression* CXFA_FMParse::ParseIfExpression() { return ParseExpExpression(); } Check(TOKthen); - std::unique_ptr<CXFA_FMExpression> pIfExpression(ParseBlockExpression()); + std::unique_ptr<CXFA_FMExpression> pIfExpression = ParseBlockExpression(); std::unique_ptr<CXFA_FMExpression> pElseExpression; switch (m_pToken->m_type) { case TOKeof: @@ -883,15 +879,15 @@ CXFA_FMExpression* CXFA_FMParse::ParseIfExpression() { Check(TOKendif); break; case TOKif: - pElseExpression.reset(ParseIfExpression()); + pElseExpression = ParseIfExpression(); Check(TOKendif); break; case TOKelseif: - pElseExpression.reset(ParseIfExpression()); + pElseExpression = ParseIfExpression(); break; case TOKelse: NextToken(); - pElseExpression.reset(ParseBlockExpression()); + pElseExpression = ParseBlockExpression(); Check(TOKendif); break; default: @@ -902,33 +898,34 @@ CXFA_FMExpression* CXFA_FMParse::ParseIfExpression() { } std::unique_ptr<CXFA_FMIfExpression> pExp; if (m_pErrorInfo->message.IsEmpty()) { - pExp.reset(new CXFA_FMIfExpression(line, pExpression.release(), - pIfExpression.release(), - pElseExpression.release())); + pExp = pdfium::MakeUnique<CXFA_FMIfExpression>(line, pExpression.release(), + pIfExpression.release(), + pElseExpression.release()); } - return pExp.release(); + return pExp; } -CXFA_FMExpression* CXFA_FMParse::ParseWhileExpression() { +std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseWhileExpression() { uint32_t line = m_pToken->m_uLinenum; NextToken(); - std::unique_ptr<CXFA_FMSimpleExpression> pCondition(ParseParenExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> pCondition = ParseParenExpression(); Check(TOKdo); - std::unique_ptr<CXFA_FMExpression> pExpression(ParseBlockExpression()); + std::unique_ptr<CXFA_FMExpression> pExpression = ParseBlockExpression(); Check(TOKendwhile); - std::unique_ptr<CXFA_FMExpression> e; + std::unique_ptr<CXFA_FMExpression> expr; if (m_pErrorInfo->message.IsEmpty()) { - e.reset(new CXFA_FMWhileExpression(line, pCondition.release(), - pExpression.release())); + expr = pdfium::MakeUnique<CXFA_FMWhileExpression>( + line, pCondition.release(), pExpression.release()); } - return e.release(); + return expr; } -CXFA_FMSimpleExpression* CXFA_FMParse::ParseSubassignmentInForExpression() { - std::unique_ptr<CXFA_FMSimpleExpression> e; +std::unique_ptr<CXFA_FMSimpleExpression> +CXFA_FMParse::ParseSubassignmentInForExpression() { + std::unique_ptr<CXFA_FMSimpleExpression> expr; switch (m_pToken->m_type) { case TOKidentifier: - e.reset(ParseSimpleExpression()); + expr = ParseSimpleExpression(); break; default: CFX_WideString ws_TempString(m_pToken->m_wstring); @@ -937,10 +934,10 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseSubassignmentInForExpression() { NextToken(); break; } - return e.release(); + return expr; } -CXFA_FMExpression* CXFA_FMParse::ParseForExpression() { +std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseForExpression() { CFX_WideStringC wsVariant; uint32_t line = m_pToken->m_uLinenum; NextToken(); @@ -954,7 +951,7 @@ CXFA_FMExpression* CXFA_FMParse::ParseForExpression() { std::unique_ptr<CXFA_FMSimpleExpression> pAssignment; if (m_pToken->m_type == TOKassign) { NextToken(); - pAssignment.reset(ParseSimpleExpression()); + pAssignment = ParseSimpleExpression(); } else { CFX_WideString ws_TempString(m_pToken->m_wstring); Error(m_pToken->m_uLinenum, kFMErrExpectedToken, @@ -971,26 +968,26 @@ CXFA_FMExpression* CXFA_FMParse::ParseForExpression() { ws_TempString.c_str()); } NextToken(); - std::unique_ptr<CXFA_FMSimpleExpression> pAccessor(ParseSimpleExpression()); + std::unique_ptr<CXFA_FMSimpleExpression> pAccessor = ParseSimpleExpression(); std::unique_ptr<CXFA_FMSimpleExpression> pStep; if (m_pToken->m_type == TOKstep) { NextToken(); - pStep.reset(ParseSimpleExpression()); + pStep = ParseSimpleExpression(); } Check(TOKdo); - std::unique_ptr<CXFA_FMExpression> pList(ParseBlockExpression()); + std::unique_ptr<CXFA_FMExpression> pList = ParseBlockExpression(); Check(TOKendfor); - std::unique_ptr<CXFA_FMExpression> e; + std::unique_ptr<CXFA_FMExpression> expr; if (m_pErrorInfo->message.IsEmpty()) { - e.reset(new CXFA_FMForExpression(line, wsVariant, pAssignment.release(), - pAccessor.release(), iDirection, - pStep.release(), pList.release())); + expr = pdfium::MakeUnique<CXFA_FMForExpression>( + line, wsVariant, pAssignment.release(), pAccessor.release(), iDirection, + pStep.release(), pList.release()); } - return e.release(); + return expr; } -CXFA_FMExpression* CXFA_FMParse::ParseForeachExpression() { - std::unique_ptr<CXFA_FMExpression> e; +std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseForeachExpression() { + std::unique_ptr<CXFA_FMExpression> expr; CFX_WideStringC wsIdentifier; std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> pAccessors; std::unique_ptr<CXFA_FMExpression> pList; @@ -1012,9 +1009,9 @@ CXFA_FMExpression* CXFA_FMParse::ParseForeachExpression() { NextToken(); } else { while (m_pToken->m_type != TOKrparen) { - CXFA_FMSimpleExpression* s = ParseSimpleExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> s = ParseSimpleExpression(); if (s) - pAccessors.push_back(pdfium::WrapUnique<CXFA_FMSimpleExpression>(s)); + pAccessors.push_back(std::move(s)); if (m_pToken->m_type != TOKcomma) break; NextToken(); @@ -1022,25 +1019,24 @@ CXFA_FMExpression* CXFA_FMParse::ParseForeachExpression() { Check(TOKrparen); } Check(TOKdo); - pList.reset(ParseBlockExpression()); + pList = ParseBlockExpression(); Check(TOKendfor); if (m_pErrorInfo->message.IsEmpty()) { - e = pdfium::MakeUnique<CXFA_FMForeachExpression>( + expr = pdfium::MakeUnique<CXFA_FMForeachExpression>( line, wsIdentifier, std::move(pAccessors), pList.release()); } - return e.release(); + return expr; } -CXFA_FMExpression* CXFA_FMParse::ParseDoExpression() { - std::unique_ptr<CXFA_FMExpression> e; +std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseDoExpression() { uint32_t line = m_pToken->m_uLinenum; NextToken(); - e.reset(ParseBlockExpression()); + std::unique_ptr<CXFA_FMExpression> expr = ParseBlockExpression(); Check(TOKend); if (m_pErrorInfo->message.IsEmpty()) { - e.reset(new CXFA_FMDoExpression(line, e.release())); + expr = pdfium::MakeUnique<CXFA_FMDoExpression>(line, expr.release()); } else { - e.reset(); + expr.reset(); } - return e.release(); + return expr; } diff --git a/xfa/fxfa/fm2js/xfa_fmparse.h b/xfa/fxfa/fm2js/xfa_fmparse.h index 0283edaed0..5f8022f270 100644 --- a/xfa/fxfa/fm2js/xfa_fmparse.h +++ b/xfa/fxfa/fm2js/xfa_fmparse.h @@ -8,6 +8,7 @@ #define XFA_FXFA_FM2JS_XFA_FMPARSE_H_ #include <memory> +#include <vector> #include "xfa/fxfa/fm2js/xfa_expression.h" #include "xfa/fxfa/fm2js/xfa_lexer.h" @@ -21,30 +22,31 @@ class CXFA_FMParse { void NextToken(); void Check(XFA_FM_TOKEN op); void Error(uint32_t lineNum, const FX_WCHAR* msg, ...); - CFX_ArrayTemplate<CXFA_FMExpression*>* ParseTopExpression(); - CXFA_FMExpression* ParseFunction(); - CXFA_FMExpression* ParseExpression(); - CXFA_FMExpression* ParseVarExpression(); - CXFA_FMExpression* ParseExpExpression(); - CXFA_FMExpression* ParseBlockExpression(); - CXFA_FMExpression* ParseIfExpression(); - CXFA_FMExpression* ParseWhileExpression(); - CXFA_FMExpression* ParseForExpression(); - CXFA_FMExpression* ParseForeachExpression(); - CXFA_FMExpression* ParseDoExpression(); - CXFA_FMSimpleExpression* ParseParenExpression(); - CXFA_FMSimpleExpression* ParseSimpleExpression(); - CXFA_FMSimpleExpression* ParseSubassignmentInForExpression(); - CXFA_FMSimpleExpression* ParseLogicalOrExpression(); - CXFA_FMSimpleExpression* ParseLogicalAndExpression(); - CXFA_FMSimpleExpression* ParseEqualityExpression(); - CXFA_FMSimpleExpression* ParseRelationalExpression(); - CXFA_FMSimpleExpression* ParseAddtiveExpression(); - CXFA_FMSimpleExpression* ParseMultiplicativeExpression(); - CXFA_FMSimpleExpression* ParseUnaryExpression(); - CXFA_FMSimpleExpression* ParsePrimaryExpression(); - CXFA_FMSimpleExpression* ParsePostExpression(CXFA_FMSimpleExpression* e); - CXFA_FMSimpleExpression* ParseIndexExpression(); + std::vector<std::unique_ptr<CXFA_FMExpression>> ParseTopExpression(); + std::unique_ptr<CXFA_FMExpression> ParseFunction(); + std::unique_ptr<CXFA_FMExpression> ParseExpression(); + std::unique_ptr<CXFA_FMExpression> ParseVarExpression(); + std::unique_ptr<CXFA_FMExpression> ParseExpExpression(); + std::unique_ptr<CXFA_FMExpression> ParseBlockExpression(); + std::unique_ptr<CXFA_FMExpression> ParseIfExpression(); + std::unique_ptr<CXFA_FMExpression> ParseWhileExpression(); + std::unique_ptr<CXFA_FMExpression> ParseForExpression(); + std::unique_ptr<CXFA_FMExpression> ParseForeachExpression(); + std::unique_ptr<CXFA_FMExpression> ParseDoExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParseParenExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParseSimpleExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParseSubassignmentInForExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParseLogicalOrExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParseLogicalAndExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParseEqualityExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParseRelationalExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParseAddtiveExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParseMultiplicativeExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParseUnaryExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParsePrimaryExpression(); + std::unique_ptr<CXFA_FMSimpleExpression> ParsePostExpression( + std::unique_ptr<CXFA_FMSimpleExpression> e); + std::unique_ptr<CXFA_FMSimpleExpression> ParseIndexExpression(); private: std::unique_ptr<CXFA_FMLexer> m_lexer; diff --git a/xfa/fxfa/fm2js/xfa_program.cpp b/xfa/fxfa/fm2js/xfa_program.cpp index 5146a5e129..ac18c15e6d 100644 --- a/xfa/fxfa/fm2js/xfa_program.cpp +++ b/xfa/fxfa/fm2js/xfa_program.cpp @@ -6,6 +6,11 @@ #include "xfa/fxfa/fm2js/xfa_program.h" +#include <utility> +#include <vector> + +#include "third_party/base/ptr_util.h" + CXFA_FMProgram::CXFA_FMProgram() {} CXFA_FMProgram::~CXFA_FMProgram() {} @@ -15,21 +20,17 @@ int32_t CXFA_FMProgram::Init(const CFX_WideStringC& wsFormcalc) { } int32_t CXFA_FMProgram::ParseProgram() { - CFX_ArrayTemplate<CXFA_FMExpression*>* expressions = nullptr; m_parse.NextToken(); - if (!m_pErrorInfo.message.IsEmpty()) { + if (!m_pErrorInfo.message.IsEmpty()) return -1; - } - expressions = m_parse.ParseTopExpression(); - if (!m_pErrorInfo.message.IsEmpty()) { - for (int32_t u = 0; u < expressions->GetSize(); ++u) - delete expressions->GetAt(u); - delete expressions; + std::vector<std::unique_ptr<CXFA_FMExpression>> expressions = + m_parse.ParseTopExpression(); + if (!m_pErrorInfo.message.IsEmpty()) return -1; - } - m_globalFunction.reset( - new CXFA_FMFunctionDefinition(1, 1, FX_WSTRC(L""), nullptr, expressions)); + + m_globalFunction = pdfium::MakeUnique<CXFA_FMFunctionDefinition>( + 1, true, L"", nullptr, std::move(expressions)); return 0; } diff --git a/xfa/fxfa/fm2js/xfa_simpleexpression.cpp b/xfa/fxfa/fm2js/xfa_simpleexpression.cpp index be02e51ec4..e52cd88979 100644 --- a/xfa/fxfa/fm2js/xfa_simpleexpression.cpp +++ b/xfa/fxfa/fm2js/xfa_simpleexpression.cpp @@ -6,6 +6,8 @@ #include "xfa/fxfa/fm2js/xfa_simpleexpression.h" +#include <utility> + #include "core/fxcrt/fx_ext.h" namespace { @@ -477,20 +479,13 @@ void CXFA_FMNotExpression::ToJavaScript(CFX_WideTextBuf& javascript) { CXFA_FMCallExpression::CXFA_FMCallExpression( uint32_t line, CXFA_FMSimpleExpression* pExp, - CFX_ArrayTemplate<CXFA_FMSimpleExpression*>* pArguments, + std::vector<std::unique_ptr<CXFA_FMSimpleExpression>>&& pArguments, bool bIsSomMethod) : CXFA_FMUnaryExpression(line, TOKcall, pExp), m_bIsSomMethod(bIsSomMethod), - m_pArguments(pArguments) {} - -CXFA_FMCallExpression::~CXFA_FMCallExpression() { - if (m_pArguments) { - for (int i = 0; i < m_pArguments->GetSize(); ++i) - delete m_pArguments->GetAt(i); + m_Arguments(std::move(pArguments)) {} - delete m_pArguments; - } -} +CXFA_FMCallExpression::~CXFA_FMCallExpression() {} bool CXFA_FMCallExpression::IsBuildInFunc(CFX_WideTextBuf* funcName) { uint32_t uHash = FX_HashCode_GetW(funcName->AsStringC(), true); @@ -536,41 +531,37 @@ void CXFA_FMCallExpression::ToJavaScript(CFX_WideTextBuf& javascript) { m_pExp->ToJavaScript(funcName); if (m_bIsSomMethod) { javascript << funcName; - javascript << FX_WSTRC(L"("); - if (m_pArguments) { - uint32_t methodPara = IsMethodWithObjParam(funcName.AsStringC()); - if (methodPara > 0) { - for (int i = 0; i < m_pArguments->GetSize(); ++i) { - // Currently none of our expressions use objects for a parameter over - // the 6th. Make sure we don't overflow the shift when doing this - // check. If we ever need more the 32 object params we can revisit. - if (i < 32 && (methodPara & (0x01 << i)) > 0) { - javascript << gs_lpStrExpFuncName[GETFMJSOBJ]; - } else { - javascript << gs_lpStrExpFuncName[GETFMVALUE]; - } - javascript << FX_WSTRC(L"("); - CXFA_FMSimpleExpression* e = m_pArguments->GetAt(i); - e->ToJavaScript(javascript); - javascript << FX_WSTRC(L")"); - if (i + 1 < m_pArguments->GetSize()) { - javascript << FX_WSTRC(L", "); - } - } - } else { - for (int i = 0; i < m_pArguments->GetSize(); ++i) { + javascript << L"("; + uint32_t methodPara = IsMethodWithObjParam(funcName.AsStringC()); + if (methodPara > 0) { + for (size_t i = 0; i < m_Arguments.size(); ++i) { + // Currently none of our expressions use objects for a parameter over + // the 6th. Make sure we don't overflow the shift when doing this + // check. If we ever need more the 32 object params we can revisit. + if (i < 32 && (methodPara & (0x01 << i)) > 0) { + javascript << gs_lpStrExpFuncName[GETFMJSOBJ]; + } else { javascript << gs_lpStrExpFuncName[GETFMVALUE]; - javascript << FX_WSTRC(L"("); - CXFA_FMSimpleExpression* e = m_pArguments->GetAt(i); - e->ToJavaScript(javascript); - javascript << FX_WSTRC(L")"); - if (i + 1 < m_pArguments->GetSize()) { - javascript << FX_WSTRC(L", "); - } } + javascript << L"("; + const auto& expr = m_Arguments[i]; + expr->ToJavaScript(javascript); + javascript << L")"; + if (i + 1 < m_Arguments.size()) { + javascript << L", "; + } + } + } else { + for (const auto& expr : m_Arguments) { + javascript << gs_lpStrExpFuncName[GETFMVALUE]; + javascript << L"("; + expr->ToJavaScript(javascript); + javascript << L")"; + if (expr != m_Arguments.back()) + javascript << L", "; } } - javascript << FX_WSTRC(L")"); + javascript << L")"; } else { bool isEvalFunc = false; bool isExistsFunc = false; @@ -594,28 +585,26 @@ void CXFA_FMCallExpression::ToJavaScript(CFX_WideTextBuf& javascript) { javascript << FX_WSTRC(L"("); if (isExistsFunc) { javascript << FX_WSTRC(L"\n(\nfunction ()\n{\ntry\n{\n"); - if (m_pArguments && m_pArguments->GetSize() > 0) { - CXFA_FMSimpleExpression* e = m_pArguments->GetAt(0); + if (!m_Arguments.empty()) { + const auto& expr = m_Arguments[0]; javascript << FX_WSTRC(L"return "); - e->ToJavaScript(javascript); + expr->ToJavaScript(javascript); javascript << FX_WSTRC(L";\n}\n"); } else { javascript << FX_WSTRC(L"return 0;\n}\n"); } javascript << FX_WSTRC( L"catch(accessExceptions)\n{\nreturn 0;\n}\n}\n).call(this)\n"); - } else if (m_pArguments) { - for (int i = 0; i < m_pArguments->GetSize(); ++i) { - CXFA_FMSimpleExpression* e = m_pArguments->GetAt(i); - e->ToJavaScript(javascript); - if (i + 1 < m_pArguments->GetSize()) { - javascript << FX_WSTRC(L", "); - } + } else { + for (const auto& expr : m_Arguments) { + expr->ToJavaScript(javascript); + if (expr != m_Arguments.back()) + javascript << L", "; } } - javascript << FX_WSTRC(L")"); + javascript << L")"; if (isEvalFunc) { - javascript << FX_WSTRC(L")"); + javascript << L")"; } } } diff --git a/xfa/fxfa/fm2js/xfa_simpleexpression.h b/xfa/fxfa/fm2js/xfa_simpleexpression.h index 6c1e6257bd..c96d990b08 100644 --- a/xfa/fxfa/fm2js/xfa_simpleexpression.h +++ b/xfa/fxfa/fm2js/xfa_simpleexpression.h @@ -8,6 +8,7 @@ #define XFA_FXFA_FM2JS_XFA_SIMPLEEXPRESSION_H_ #include <memory> +#include <vector> #include "core/fxcrt/fx_basic.h" #include "xfa/fxfa/fm2js/xfa_lexer.h" @@ -228,10 +229,11 @@ class CXFA_FMNotExpression : public CXFA_FMUnaryExpression { class CXFA_FMCallExpression : public CXFA_FMUnaryExpression { public: - CXFA_FMCallExpression(uint32_t line, - CXFA_FMSimpleExpression* pExp, - CFX_ArrayTemplate<CXFA_FMSimpleExpression*>* pArguments, - bool bIsSomMethod); + CXFA_FMCallExpression( + uint32_t line, + CXFA_FMSimpleExpression* pExp, + std::vector<std::unique_ptr<CXFA_FMSimpleExpression>>&& pArguments, + bool bIsSomMethod); ~CXFA_FMCallExpression() override; bool IsBuildInFunc(CFX_WideTextBuf* funcName); @@ -240,7 +242,7 @@ class CXFA_FMCallExpression : public CXFA_FMUnaryExpression { private: bool m_bIsSomMethod; - CFX_ArrayTemplate<CXFA_FMSimpleExpression*>* m_pArguments; + std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> m_Arguments; }; class CXFA_FMDotAccessorExpression : public CXFA_FMBinExpression { diff --git a/xfa/fxfa/fm2js/xfa_simpleexpression_unittest.cpp b/xfa/fxfa/fm2js/xfa_simpleexpression_unittest.cpp index 534fc18a6f..d54921f99a 100644 --- a/xfa/fxfa/fm2js/xfa_simpleexpression_unittest.cpp +++ b/xfa/fxfa/fm2js/xfa_simpleexpression_unittest.cpp @@ -5,21 +5,21 @@ #include "xfa/fxfa/fm2js/xfa_simpleexpression.h" #include <memory> +#include <utility> #include "testing/gtest/include/gtest/gtest.h" +#include "third_party/base/ptr_util.h" #include "xfa/fxfa/fm2js/xfa_lexer.h" TEST(FMCallExpression, more_than_32_arguments) { // Use sign as it has 3 object parameters at positions 0, 5, and 6. - std::unique_ptr<CXFA_FMIdentifierExpression> exp( - new CXFA_FMIdentifierExpression(0, CFX_WideStringC(L"sign"))); + auto exp = pdfium::MakeUnique<CXFA_FMIdentifierExpression>(0, L"sign"); - std::unique_ptr<CFX_ArrayTemplate<CXFA_FMSimpleExpression*>> args( - new CFX_ArrayTemplate<CXFA_FMSimpleExpression*>()); + std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> args; for (size_t i = 0; i < 50; i++) - args->Add(new CXFA_FMSimpleExpression(0, TOKnan)); + args.push_back(pdfium::MakeUnique<CXFA_FMSimpleExpression>(0, TOKnan)); - CXFA_FMCallExpression callExp(0, exp.release(), args.release(), true); + CXFA_FMCallExpression callExp(0, exp.release(), std::move(args), true); CFX_WideTextBuf js; callExp.ToJavaScript(js); |