Use unique pointers in CXFA_FMParse
Replaced CXFA_FMParse's returns to be unique pointers to prevent leaks.
Review-Url: https://codereview.chromium.org/2530933002
diff --git a/xfa/fxfa/fm2js/xfa_expression.cpp b/xfa/fxfa/fm2js/xfa_expression.cpp
index 5734593..8d1888a 100644
--- a/xfa/fxfa/fm2js/xfa_expression.cpp
+++ b/xfa/fxfa/fm2js/xfa_expression.cpp
@@ -35,24 +35,17 @@
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 @@
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 @@
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 @@
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 @@
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 236b51a..f89a923 100644
--- a/xfa/fxfa/fm2js/xfa_expression.h
+++ b/xfa/fxfa/fm2js/xfa_expression.h
@@ -46,7 +46,7 @@
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 @@
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_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 36663fc..07edc32 100644
--- a/xfa/fxfa/fm2js/xfa_fmparse.cpp
+++ b/xfa/fxfa/fm2js/xfa_fmparse.cpp
@@ -19,7 +19,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
}
}
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 @@
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 @@
}
}
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 0283eda..5f8022f 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 @@
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 5146a5e..ac18c15 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::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 be02e51..e52cd88 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 @@
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) {}
+ m_Arguments(std::move(pArguments)) {}
-CXFA_FMCallExpression::~CXFA_FMCallExpression() {
- if (m_pArguments) {
- for (int i = 0; i < m_pArguments->GetSize(); ++i)
- delete m_pArguments->GetAt(i);
-
- 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 @@
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 @@
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 6c1e625..c96d990 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_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 @@
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 534fc18..d54921f 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);