From 5870b76eab54b30491e1dc35ce09a308462af29a Mon Sep 17 00:00:00 2001 From: Lei Zhang Date: Thu, 25 Feb 2016 12:40:20 -0800 Subject: Use std::unique_ptr in CXFA_FMParse. R=dsinclair@chromium.org Review URL: https://codereview.chromium.org/1740643002 . --- xfa/src/fxfa/src/fm2js/xfa_fmparse.cpp | 592 ++++++++++++++------------------- 1 file changed, 244 insertions(+), 348 deletions(-) diff --git a/xfa/src/fxfa/src/fm2js/xfa_fmparse.cpp b/xfa/src/fxfa/src/fm2js/xfa_fmparse.cpp index b451aa5487..c5f6efb4f5 100644 --- a/xfa/src/fxfa/src/fm2js/xfa_fmparse.cpp +++ b/xfa/src/fxfa/src/fm2js/xfa_fmparse.cpp @@ -6,6 +6,8 @@ #include "xfa/src/fxfa/src/fm2js/xfa_fm2js.h" +#include + CXFA_FMParse::CXFA_FMParse() : m_pToken(nullptr), m_pErrorInfo(0) {} int32_t CXFA_FMParse::Init(const CFX_WideStringC& wsFormcalc, @@ -44,7 +46,7 @@ void CXFA_FMParse::Error(FX_DWORD lineNum, XFA_FM_ERRMSG msg, ...) { } CFX_PtrArray* CXFA_FMParse::ParseTopExpression() { - CXFA_FMExpression* e = 0; + std::unique_ptr e; CFX_PtrArray* expression = new CFX_PtrArray(); while (1) { if (m_pToken->m_type == TOKeof || m_pToken->m_type == TOKendfunc || @@ -54,16 +56,16 @@ CFX_PtrArray* CXFA_FMParse::ParseTopExpression() { } if (m_pToken->m_type == TOKfunc) { - e = ParseFunction(); + e.reset(ParseFunction()); if (e) { - expression->Add(e); + expression->Add(e.release()); } else { break; } } else { - e = ParseExpression(); + e.reset(ParseExpression()); if (e) { - expression->Add(e); + expression->Add(e.release()); } else { break; } @@ -73,10 +75,10 @@ CFX_PtrArray* CXFA_FMParse::ParseTopExpression() { } CXFA_FMExpression* CXFA_FMParse::ParseFunction() { - CXFA_FMExpression* e = 0; + std::unique_ptr e; CFX_WideStringC ident; - CFX_WideStringCArray* pArguments = 0; - CFX_PtrArray* pExpressions = 0; + std::unique_ptr pArguments; + std::unique_ptr pExpressions; FX_DWORD line = m_pToken->m_uLinenum; NextToken(); if (m_pToken->m_type != TOKidentifier) { @@ -91,7 +93,7 @@ CXFA_FMExpression* CXFA_FMParse::ParseFunction() { if (m_pToken->m_type == TOKrparen) { NextToken(); } else { - pArguments = new CFX_WideStringCArray(); + pArguments.reset(new CFX_WideStringCArray()); CFX_WideStringC p; while (1) { if (m_pToken->m_type == TOKidentifier) { @@ -121,42 +123,29 @@ CXFA_FMExpression* CXFA_FMParse::ParseFunction() { if (m_pToken->m_type == TOKendfunc) { NextToken(); } else { - pExpressions = ParseTopExpression(); + pExpressions.reset(ParseTopExpression()); Check(TOKendfunc); } if (m_pErrorInfo->message.IsEmpty()) { - e = new CXFA_FMFunctionDefinition(line, 0, ident, pArguments, pExpressions); + e.reset(new CXFA_FMFunctionDefinition(line, 0, ident, pArguments.release(), + pExpressions.release())); } else { - int32_t size = 0; - int32_t index = 0; - if (pArguments) { + if (pArguments) pArguments->RemoveAll(); - delete pArguments; - pArguments = 0; - } - index = 0; if (pExpressions) { - CXFA_FMExpression* e1 = 0; - size = pExpressions->GetSize(); - while (index < size) { - e1 = (CXFA_FMExpression*)pExpressions->GetAt(index); - delete e1; - index++; - } - pExpressions->RemoveAll(); - delete pExpressions; - pExpressions = 0; + for (int i = 0; i < pExpressions->GetSize(); ++i) + delete static_cast(pExpressions->GetAt(i)); } } - return e; + return e.release(); } CXFA_FMExpression* CXFA_FMParse::ParseExpression() { - CXFA_FMExpression* e = 0; + std::unique_ptr e; FX_DWORD line = m_pToken->m_uLinenum; switch (m_pToken->m_type) { case TOKvar: - e = ParseVarExpression(); + e.reset(ParseVarExpression()); break; case TOKnull: case TOKnumber: @@ -166,29 +155,29 @@ CXFA_FMExpression* CXFA_FMParse::ParseExpression() { case TOKksnot: case TOKidentifier: case TOKlparen: - e = ParseExpExpression(); + e.reset(ParseExpExpression()); break; case TOKif: - e = ParseIfExpression(); + e.reset(ParseIfExpression()); break; case TOKwhile: - e = ParseWhileExpression(); + e.reset(ParseWhileExpression()); break; case TOKfor: - e = ParseForExpression(); + e.reset(ParseForExpression()); break; case TOKforeach: - e = ParseForeachExpression(); + e.reset(ParseForeachExpression()); break; case TOKdo: - e = ParseDoExpression(); + e.reset(ParseDoExpression()); break; case TOKbreak: - e = new CXFA_FMBreakExpression(line); + e.reset(new CXFA_FMBreakExpression(line)); NextToken(); break; case TOKcontinue: - e = new CXFA_FMContinueExpression(line); + e.reset(new CXFA_FMContinueExpression(line)); NextToken(); break; default: @@ -198,11 +187,11 @@ CXFA_FMExpression* CXFA_FMParse::ParseExpression() { NextToken(); break; } - return e; + return e.release(); } CXFA_FMExpression* CXFA_FMParse::ParseVarExpression() { - CXFA_FMExpression* e = 0; + std::unique_ptr e; CFX_WideStringC ident; FX_DWORD line = m_pToken->m_uLinenum; NextToken(); @@ -216,124 +205,121 @@ CXFA_FMExpression* CXFA_FMParse::ParseVarExpression() { } if (m_pToken->m_type == TOKassign) { NextToken(); - e = ParseExpExpression(); + e.reset(ParseExpExpression()); } if (m_pErrorInfo->message.IsEmpty()) { - e = new CXFA_FMVarExpression(line, ident, e); + e.reset(new CXFA_FMVarExpression(line, ident, e.release())); } else { - delete e; - e = 0; + e.reset(); } - return e; + return e.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParseSimpleExpression() { FX_DWORD line = m_pToken->m_uLinenum; - CXFA_FMSimpleExpression *pExp1 = 0, *pExp2 = 0; - pExp1 = ParseLogicalOrExpression(); + std::unique_ptr pExp1(ParseLogicalOrExpression()); while (m_pToken->m_type == TOKassign) { NextToken(); - pExp2 = ParseLogicalOrExpression(); + std::unique_ptr pExp2(ParseLogicalOrExpression()); if (m_pErrorInfo->message.IsEmpty()) { - pExp1 = new CXFA_FMAssignExpression(line, TOKassign, pExp1, pExp2); + pExp1.reset(new CXFA_FMAssignExpression(line, TOKassign, pExp1.release(), + pExp2.release())); } else { - delete pExp1; - pExp1 = 0; + pExp1.reset(); } } - return pExp1; + return pExp1.release(); } CXFA_FMExpression* CXFA_FMParse::ParseExpExpression() { - CXFA_FMExpression* e = 0; FX_DWORD line = m_pToken->m_uLinenum; - CXFA_FMSimpleExpression* pExp1 = 0; - pExp1 = ParseSimpleExpression(); + std::unique_ptr pExp1(ParseSimpleExpression()); + std::unique_ptr e; if (m_pErrorInfo->message.IsEmpty()) { - e = new CXFA_FMExpExpression(line, pExp1); + e.reset(new CXFA_FMExpExpression(line, pExp1.release())); } else { - delete pExp1; - e = 0; + e.reset(); } - return e; + return e.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalOrExpression() { - CXFA_FMSimpleExpression *e1 = 0, *e2 = 0; FX_DWORD line = m_pToken->m_uLinenum; - e1 = ParseLogicalAndExpression(); + std::unique_ptr e1(ParseLogicalAndExpression()); for (;;) { switch (m_pToken->m_type) { case TOKor: - case TOKksor: + case TOKksor: { NextToken(); - e2 = ParseLogicalAndExpression(); + std::unique_ptr e2( + ParseLogicalAndExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMLogicalOrExpression(line, TOKor, e1, e2); + e1.reset(new CXFA_FMLogicalOrExpression(line, TOKor, e1.release(), + e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; + } default: break; } break; } - return e1; + return e1.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalAndExpression() { - CXFA_FMSimpleExpression *e1 = 0, *e2 = 0; FX_DWORD line = m_pToken->m_uLinenum; - e1 = ParseEqualityExpression(); + std::unique_ptr e1(ParseEqualityExpression()); for (;;) { switch (m_pToken->m_type) { case TOKand: - case TOKksand: + case TOKksand: { NextToken(); - e2 = ParseEqualityExpression(); + std::unique_ptr e2(ParseEqualityExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMLogicalAndExpression(line, TOKand, e1, e2); + e1.reset(new CXFA_FMLogicalAndExpression(line, TOKand, e1.release(), + e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; + } default: break; } break; } - return e1; + return e1.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParseEqualityExpression() { - CXFA_FMSimpleExpression *e1 = 0, *e2 = 0; FX_DWORD line = m_pToken->m_uLinenum; - e1 = ParseRelationalExpression(); + std::unique_ptr e1(ParseRelationalExpression()); for (;;) { + std::unique_ptr e2; switch (m_pToken->m_type) { case TOKeq: case TOKkseq: NextToken(); - e2 = ParseRelationalExpression(); + e2.reset(ParseRelationalExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMEqualityExpression(line, TOKeq, e1, e2); + e1.reset(new CXFA_FMEqualityExpression(line, TOKeq, e1.release(), + e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; case TOKne: case TOKksne: NextToken(); - e2 = ParseRelationalExpression(); + e2.reset(ParseRelationalExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMEqualityExpression(line, TOKne, e1, e2); + e1.reset(new CXFA_FMEqualityExpression(line, TOKne, e1.release(), + e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; default: @@ -341,57 +327,57 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseEqualityExpression() { } break; } - return e1; + return e1.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParseRelationalExpression() { - CXFA_FMSimpleExpression *e1 = 0, *e2 = 0; FX_DWORD line = m_pToken->m_uLinenum; - e1 = ParseAddtiveExpression(); + std::unique_ptr e1(ParseAddtiveExpression()); for (;;) { + std::unique_ptr e2; switch (m_pToken->m_type) { case TOKlt: case TOKkslt: NextToken(); - e2 = ParseAddtiveExpression(); + e2.reset(ParseAddtiveExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMRelationalExpression(line, TOKlt, e1, e2); + e1.reset(new CXFA_FMRelationalExpression(line, TOKlt, e1.release(), + e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; case TOKgt: case TOKksgt: NextToken(); - e2 = ParseAddtiveExpression(); + e2.reset(ParseAddtiveExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMRelationalExpression(line, TOKgt, e1, e2); + e1.reset(new CXFA_FMRelationalExpression(line, TOKgt, e1.release(), + e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; case TOKle: case TOKksle: NextToken(); - e2 = ParseAddtiveExpression(); + e2.reset(ParseAddtiveExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMRelationalExpression(line, TOKle, e1, e2); + e1.reset(new CXFA_FMRelationalExpression(line, TOKle, e1.release(), + e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; case TOKge: case TOKksge: NextToken(); - e2 = ParseAddtiveExpression(); + e2.reset(ParseAddtiveExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMRelationalExpression(line, TOKge, e1, e2); + e1.reset(new CXFA_FMRelationalExpression(line, TOKge, e1.release(), + e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; default: @@ -399,33 +385,33 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseRelationalExpression() { } break; } - return e1; + return e1.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParseAddtiveExpression() { - CXFA_FMSimpleExpression *e1 = 0, *e2 = 0; FX_DWORD line = m_pToken->m_uLinenum; - e1 = ParseMultiplicativeExpression(); + std::unique_ptr e1(ParseMultiplicativeExpression()); for (;;) { + std::unique_ptr e2; switch (m_pToken->m_type) { case TOKplus: NextToken(); - e2 = ParseMultiplicativeExpression(); + e2.reset(ParseMultiplicativeExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMAdditiveExpression(line, TOKplus, e1, e2); + e1.reset(new CXFA_FMAdditiveExpression(line, TOKplus, e1.release(), + e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; case TOKminus: NextToken(); - e2 = ParseMultiplicativeExpression(); + e2.reset(ParseMultiplicativeExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMAdditiveExpression(line, TOKminus, e1, e2); + e1.reset(new CXFA_FMAdditiveExpression(line, TOKminus, e1.release(), + e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; default: @@ -433,33 +419,33 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseAddtiveExpression() { } break; } - return e1; + return e1.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParseMultiplicativeExpression() { - CXFA_FMSimpleExpression *e1 = 0, *e2 = 0; FX_DWORD line = m_pToken->m_uLinenum; - e1 = ParseUnaryExpression(); + std::unique_ptr e1(ParseUnaryExpression()); for (;;) { + std::unique_ptr e2; switch (m_pToken->m_type) { case TOKmul: NextToken(); - e2 = ParseUnaryExpression(); + e2.reset(ParseUnaryExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMMultiplicativeExpression(line, TOKmul, e1, e2); + e1.reset(new CXFA_FMMultiplicativeExpression( + line, TOKmul, e1.release(), e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; case TOKdiv: NextToken(); - e2 = ParseUnaryExpression(); + e2.reset(ParseUnaryExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e1 = new CXFA_FMMultiplicativeExpression(line, TOKdiv, e1, e2); + e1.reset(new CXFA_FMMultiplicativeExpression( + line, TOKdiv, e1.release(), e2.release())); } else { - delete e1; - e1 = 0; + e1.reset(); } continue; default: @@ -467,57 +453,57 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseMultiplicativeExpression() { } break; } - return e1; + return e1.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParseUnaryExpression() { - CXFA_FMSimpleExpression* e = 0; + std::unique_ptr e; FX_DWORD line = m_pToken->m_uLinenum; switch (m_pToken->m_type) { case TOKplus: NextToken(); - e = ParseUnaryExpression(); + e.reset(ParseUnaryExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e = new CXFA_FMPosExpression(line, e); + e.reset(new CXFA_FMPosExpression(line, e.release())); } else { - e = 0; + e.reset(); } break; case TOKminus: NextToken(); - e = ParseUnaryExpression(); + e.reset(ParseUnaryExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e = new CXFA_FMNegExpression(line, e); + e.reset(new CXFA_FMNegExpression(line, e.release())); } else { - e = 0; + e.reset(); } break; case TOKksnot: NextToken(); - e = ParseUnaryExpression(); + e.reset(ParseUnaryExpression()); if (m_pErrorInfo->message.IsEmpty()) { - e = new CXFA_FMNotExpression(line, e); + e.reset(new CXFA_FMNotExpression(line, e.release())); } else { - e = 0; + e.reset(); } break; default: - e = ParsePrimaryExpression(); + e.reset(ParsePrimaryExpression()); break; } - return e; + return e.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParsePrimaryExpression() { - CXFA_FMSimpleExpression* e = 0; + std::unique_ptr e; FX_DWORD line = m_pToken->m_uLinenum; switch (m_pToken->m_type) { case TOKnumber: - e = new CXFA_FMNumberExpression(line, m_pToken->m_wstring); + e.reset(new CXFA_FMNumberExpression(line, m_pToken->m_wstring)); NextToken(); break; case TOKstring: - e = new CXFA_FMStringExpression(line, m_pToken->m_wstring); + e.reset(new CXFA_FMStringExpression(line, m_pToken->m_wstring)); NextToken(); break; case TOKidentifier: { @@ -526,24 +512,24 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePrimaryExpression() { if (m_pToken->m_type == TOKlbracket) { CXFA_FMSimpleExpression* s = ParseIndexExpression(); if (s) { - e = new CXFA_FMDotAccessorExpression(line, NULL, TOKdot, wsIdentifier, - s); + e.reset(new CXFA_FMDotAccessorExpression(line, NULL, TOKdot, + wsIdentifier, s)); } NextToken(); } else { - e = new CXFA_FMIdentifierExpressionn(line, wsIdentifier); + e.reset(new CXFA_FMIdentifierExpressionn(line, wsIdentifier)); } } break; case TOKif: - e = new CXFA_FMIdentifierExpressionn(line, m_pToken->m_wstring); + e.reset(new CXFA_FMIdentifierExpressionn(line, m_pToken->m_wstring)); NextToken(); break; case TOKnull: - e = new CXFA_FMNullExpression(line); + e.reset(new CXFA_FMNullExpression(line)); NextToken(); break; case TOKlparen: - e = ParseParenExpression(); + e.reset(ParseParenExpression()); break; default: CFX_WideString ws_TempString = m_pToken->m_wstring; @@ -552,12 +538,10 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePrimaryExpression() { NextToken(); break; } - e = ParsePostExpression(e); - if (!(m_pErrorInfo->message.IsEmpty())) { - delete e; - e = 0; - } - return e; + e.reset(ParsePostExpression(e.release())); + if (!(m_pErrorInfo->message.IsEmpty())) + e.reset(); + return e.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( @@ -567,9 +551,9 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( switch (m_pToken->m_type) { case TOKlparen: { NextToken(); - CFX_PtrArray* pArray = nullptr; + std::unique_ptr pArray; if (m_pToken->m_type != TOKrparen) { - pArray = new CFX_PtrArray(); + pArray.reset(new CFX_PtrArray()); while (m_pToken->m_type != TOKrparen) { CXFA_FMSimpleExpression* e = ParseSimpleExpression(); if (e) { @@ -589,7 +573,7 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( } } if (m_pErrorInfo->message.IsEmpty()) { - e = new CXFA_FMCallExpression(line, e, pArray, FALSE); + e = new CXFA_FMCallExpression(line, e, pArray.release(), FALSE); NextToken(); if (m_pToken->m_type != TOKlbracket) { continue; @@ -600,14 +584,13 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( FX_WSTRC(L""), s); } else { delete e; - e = 0; + e = nullptr; } } else { - int32_t nSize = pArray ? pArray->GetSize() : 0; - for (int32_t i = 0; i < nSize; ++i) { - delete static_cast(pArray->GetAt(i)); + if (pArray) { + for (int32_t i = 0; i < pArray->GetSize(); ++i) + delete static_cast(pArray->GetAt(i)); } - delete pArray; delete e; e = nullptr; } @@ -623,9 +606,9 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( CXFA_FMSimpleExpression* pExpCall; pExpAccessor = e; NextToken(); - CFX_PtrArray* pArray = 0; + std::unique_ptr pArray; if (m_pToken->m_type != TOKrparen) { - pArray = new CFX_PtrArray(); + pArray.reset(new CFX_PtrArray()); while (m_pToken->m_type != TOKrparen) { CXFA_FMSimpleExpression* exp = ParseSimpleExpression(); pArray->Add(exp); @@ -645,8 +628,8 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( if (m_pErrorInfo->message.IsEmpty()) { CXFA_FMSimpleExpression* pIdentifier = new CXFA_FMIdentifierExpressionn(tempLine, tempStr); - pExpCall = - new CXFA_FMCallExpression(line, pIdentifier, pArray, TRUE); + pExpCall = new CXFA_FMCallExpression(line, pIdentifier, + pArray.release(), TRUE); e = new CXFA_FMMethodCallExpression(line, pExpAccessor, pExpCall); NextToken(); if (m_pToken->m_type != TOKlbracket) { @@ -658,34 +641,26 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( FX_WSTRC(L""), s); } else { delete e; - e = 0; + e = nullptr; } } else { - int32_t iSize = pArray->GetSize(); - for (int32_t i = 0; i < iSize; ++i) { - CXFA_FMSimpleExpression* pTemp = - (CXFA_FMSimpleExpression*)pArray->GetAt(i); - delete pTemp; + if (pArray) { + for (int32_t i = 0; i < pArray->GetSize(); ++i) { + delete static_cast( + pArray->GetAt(i)); + } } - delete pArray; delete e; - e = 0; + e = nullptr; } } else if (m_pToken->m_type == TOKlbracket) { - CXFA_FMSimpleExpression* s = ParseIndexExpression(); + std::unique_ptr s(ParseIndexExpression()); if (!(m_pErrorInfo->message.IsEmpty())) { - if (s) { - delete s; - s = 0; - } - if (e) { - delete e; - e = 0; - } - return e; + delete e; + return nullptr; } e = new CXFA_FMDotAccessorExpression(tempLine, e, TOKdot, tempStr, - s); + s.release()); } else { CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression( tempLine, ACCESSOR_NO_INDEX, NULL, FALSE); @@ -706,20 +681,13 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( FX_DWORD tempLine = m_pToken->m_uLinenum; NextToken(); if (m_pToken->m_type == TOKlbracket) { - CXFA_FMSimpleExpression* s = ParseIndexExpression(); + std::unique_ptr s(ParseIndexExpression()); if (!(m_pErrorInfo->message.IsEmpty())) { - if (s) { - delete s; - s = 0; - } - if (e) { - delete e; - e = 0; - } - return e; + delete e; + return nullptr; } e = new CXFA_FMDotDotAccessorExpression(tempLine, e, TOKdotdot, - tempStr, s); + tempStr, s.release()); } else { CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression( tempLine, ACCESSOR_NO_INDEX, NULL, FALSE); @@ -741,20 +709,13 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( FX_DWORD tempLine = m_pToken->m_uLinenum; NextToken(); if (m_pToken->m_type == TOKlbracket) { - CXFA_FMSimpleExpression* s = ParseIndexExpression(); + std::unique_ptr s(ParseIndexExpression()); if (!(m_pErrorInfo->message.IsEmpty())) { - if (s) { - delete s; - s = 0; - } - if (e) { - delete e; - e = 0; - } - return e; + delete e; + return nullptr; } e = new CXFA_FMDotAccessorExpression(tempLine, e, TOKdotscream, - tempStr, s); + tempStr, s.release()); } else { CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression( tempLine, ACCESSOR_NO_INDEX, NULL, FALSE); @@ -784,24 +745,22 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression( } CXFA_FMSimpleExpression* CXFA_FMParse::ParseIndexExpression() { - CXFA_FMSimpleExpression* pExp = 0; + std::unique_ptr pExp; FX_DWORD line = m_pToken->m_uLinenum; NextToken(); - CXFA_FMSimpleExpression* s = 0; + std::unique_ptr s; XFA_FM_AccessorIndex accessorIndex = ACCESSOR_NO_RELATIVEINDEX; if (m_pToken->m_type == TOKmul) { - pExp = new CXFA_FMIndexExpression(line, accessorIndex, s, TRUE); + pExp.reset( + new CXFA_FMIndexExpression(line, accessorIndex, s.release(), TRUE)); NextToken(); if (m_pToken->m_type != TOKrbracket) { CFX_WideString ws_TempString = m_pToken->m_wstring; Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN, XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); - if (pExp) { - delete pExp; - pExp = 0; - } + pExp.reset(); } - return pExp; + return pExp.release(); } if (m_pToken->m_type == TOKplus) { accessorIndex = ACCESSOR_POSITIVE_INDEX; @@ -810,47 +769,46 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseIndexExpression() { accessorIndex = ACCESSOR_NEGATIVE_INDEX; NextToken(); } - s = ParseSimpleExpression(); + s.reset(ParseSimpleExpression()); if (m_pToken->m_type != TOKrbracket) { CFX_WideString ws_TempString = m_pToken->m_wstring; Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN, XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); - if (s) { - delete s; - } } else { - pExp = new CXFA_FMIndexExpression(line, accessorIndex, s, FALSE); + pExp.reset( + new CXFA_FMIndexExpression(line, accessorIndex, s.release(), FALSE)); } - return pExp; + return pExp.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParseParenExpression() { - CXFA_FMSimpleExpression *pExp1 = 0, *pExp2 = 0; FX_DWORD line = m_pToken->m_uLinenum; Check(TOKlparen); + std::unique_ptr pExp1; if (m_pToken->m_type != TOKrparen) { - pExp1 = ParseLogicalOrExpression(); + pExp1.reset(ParseLogicalOrExpression()); while (m_pToken->m_type == TOKassign) { NextToken(); - pExp2 = ParseLogicalOrExpression(); + std::unique_ptr pExp2( + ParseLogicalOrExpression()); if (m_pErrorInfo->message.IsEmpty()) { - pExp1 = new CXFA_FMAssignExpression(line, TOKassign, pExp1, pExp2); + pExp1.reset(new CXFA_FMAssignExpression( + line, TOKassign, pExp1.release(), pExp2.release())); } else { - delete pExp1; - pExp1 = 0; + pExp1.reset(); } } Check(TOKrparen); } else { NextToken(); } - return pExp1; + return pExp1.release(); } CXFA_FMExpression* CXFA_FMParse::ParseBlockExpression() { FX_DWORD line = m_pToken->m_uLinenum; - CXFA_FMExpression* e = 0; - CFX_PtrArray* expression = new CFX_PtrArray(); + CXFA_FMExpression* e = nullptr; + std::unique_ptr expression(new CFX_PtrArray()); while (1) { switch (m_pToken->m_type) { case TOKeof: @@ -878,48 +836,30 @@ CXFA_FMExpression* CXFA_FMParse::ParseBlockExpression() { } break; } - CXFA_FMBlockExpression* pExp = 0; + std::unique_ptr pExp; if (m_pErrorInfo->message.IsEmpty()) { - pExp = new CXFA_FMBlockExpression(line, expression); + pExp.reset(new CXFA_FMBlockExpression(line, expression.release())); } else { - int32_t size = expression->GetSize(); - int32_t index = 0; - while (index < size) { - e = (CXFA_FMExpression*)expression->GetAt(index); - delete e; - index++; - } - expression->RemoveAll(); - delete expression; - expression = 0; + for (int i = 0; i < expression->GetSize(); ++i) + delete static_cast(expression->GetAt(i)); } - return pExp; + return pExp.release(); } CXFA_FMExpression* CXFA_FMParse::ParseIfExpression() { - CXFA_FMSimpleExpression* pExpression = 0; - CXFA_FMExpression* pIfExpression = 0; - CXFA_FMExpression* pElseExpression = 0; FX_DWORD line = m_pToken->m_uLinenum; const FX_WCHAR* pStartPos = m_lexer->SavePos(); NextToken(); Check(TOKlparen); + std::unique_ptr pExpression; while (m_pToken->m_type != TOKrparen) { - if (pExpression) { - delete pExpression; - } - pExpression = ParseSimpleExpression(); - if (m_pToken->m_type == TOKcomma) { - NextToken(); - } else { + pExpression.reset(ParseSimpleExpression()); + if (m_pToken->m_type != TOKcomma) break; - } + NextToken(); } Check(TOKrparen); if (m_pToken->m_type != TOKthen) { - if (pExpression) { - delete pExpression; - } m_lexer->SetCurrentLine(line); m_pToken = new CXFA_FMToken(line); m_pToken->m_type = TOKidentifier; @@ -929,22 +869,23 @@ CXFA_FMExpression* CXFA_FMParse::ParseIfExpression() { return ParseExpExpression(); } Check(TOKthen); - pIfExpression = ParseBlockExpression(); + std::unique_ptr pIfExpression(ParseBlockExpression()); + std::unique_ptr pElseExpression; switch (m_pToken->m_type) { case TOKeof: case TOKendif: Check(TOKendif); break; case TOKif: - pElseExpression = ParseIfExpression(); + pElseExpression.reset(ParseIfExpression()); Check(TOKendif); break; case TOKelseif: - pElseExpression = ParseIfExpression(); + pElseExpression.reset(ParseIfExpression()); break; case TOKelse: NextToken(); - pElseExpression = ParseBlockExpression(); + pElseExpression.reset(ParseBlockExpression()); Check(TOKendif); break; default: @@ -953,54 +894,35 @@ CXFA_FMExpression* CXFA_FMParse::ParseIfExpression() { NextToken(); break; } - CXFA_FMIfExpression* pExp = 0; + std::unique_ptr pExp; if (m_pErrorInfo->message.IsEmpty()) { - pExp = new CXFA_FMIfExpression(line, pExpression, pIfExpression, - pElseExpression); - } else { - if (pExpression) { - delete pExpression; - } - if (pIfExpression) { - delete pIfExpression; - } - if (pElseExpression) { - delete pElseExpression; - } + pExp.reset(new CXFA_FMIfExpression(line, pExpression.release(), + pIfExpression.release(), + pElseExpression.release())); } - return pExp; + return pExp.release(); } CXFA_FMExpression* CXFA_FMParse::ParseWhileExpression() { - CXFA_FMExpression* e = 0; - CXFA_FMSimpleExpression* pCondition = 0; - CXFA_FMExpression* pExpression = 0; FX_DWORD line = m_pToken->m_uLinenum; NextToken(); - pCondition = ParseParenExpression(); + std::unique_ptr pCondition(ParseParenExpression()); Check(TOKdo); - pExpression = ParseBlockExpression(); + std::unique_ptr pExpression(ParseBlockExpression()); Check(TOKendwhile); - if (!m_pErrorInfo->message.IsEmpty()) { - if (pCondition) { - delete pCondition; - } - if (pExpression) { - delete pExpression; - } - delete e; - e = 0; - } else { - e = new CXFA_FMWhileExpression(line, pCondition, pExpression); + std::unique_ptr e; + if (m_pErrorInfo->message.IsEmpty()) { + e.reset(new CXFA_FMWhileExpression(line, pCondition.release(), + pExpression.release())); } - return e; + return e.release(); } CXFA_FMSimpleExpression* CXFA_FMParse::ParseSubassignmentInForExpression() { - CXFA_FMSimpleExpression* e = 0; + std::unique_ptr e; switch (m_pToken->m_type) { case TOKidentifier: - e = ParseSimpleExpression(); + e.reset(ParseSimpleExpression()); break; default: CFX_WideString ws_TempString = m_pToken->m_wstring; @@ -1009,16 +931,11 @@ CXFA_FMSimpleExpression* CXFA_FMParse::ParseSubassignmentInForExpression() { NextToken(); break; } - return e; + return e.release(); } CXFA_FMExpression* CXFA_FMParse::ParseForExpression() { - CXFA_FMExpression* e = 0; CFX_WideStringC wsVariant; - CXFA_FMSimpleExpression* pAssignment = 0; - CXFA_FMSimpleExpression* pAccessor = 0; - CXFA_FMSimpleExpression* pStep = 0; - CXFA_FMExpression* pList = 0; FX_DWORD line = m_pToken->m_uLinenum; NextToken(); if (m_pToken->m_type != TOKidentifier) { @@ -1028,9 +945,10 @@ CXFA_FMExpression* CXFA_FMParse::ParseForExpression() { } wsVariant = m_pToken->m_wstring; NextToken(); + std::unique_ptr pAssignment; if (m_pToken->m_type == TOKassign) { NextToken(); - pAssignment = ParseSimpleExpression(); + pAssignment.reset(ParseSimpleExpression()); } else { CFX_WideString ws_TempString = m_pToken->m_wstring; Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN, @@ -1047,39 +965,29 @@ CXFA_FMExpression* CXFA_FMParse::ParseForExpression() { (const FX_WCHAR*)ws_TempString); } NextToken(); - pAccessor = ParseSimpleExpression(); + std::unique_ptr pAccessor(ParseSimpleExpression()); + std::unique_ptr pStep; if (m_pToken->m_type == TOKstep) { NextToken(); - pStep = ParseSimpleExpression(); + pStep.reset(ParseSimpleExpression()); } Check(TOKdo); - pList = ParseBlockExpression(); + std::unique_ptr pList(ParseBlockExpression()); Check(TOKendfor); + std::unique_ptr e; if (m_pErrorInfo->message.IsEmpty()) { - e = new CXFA_FMForExpression(line, wsVariant, pAssignment, pAccessor, - iDirection, pStep, pList); - } else { - if (pAssignment) { - delete pAssignment; - } - if (pAccessor) { - delete pAccessor; - } - if (pStep) { - delete pStep; - } - if (pList) { - delete pList; - } + e.reset(new CXFA_FMForExpression(line, wsVariant, pAssignment.release(), + pAccessor.release(), iDirection, + pStep.release(), pList.release())); } - return e; + return e.release(); } CXFA_FMExpression* CXFA_FMParse::ParseForeachExpression() { - CXFA_FMExpression* e = 0; + std::unique_ptr e; CFX_WideStringC wsIdentifier; - CFX_PtrArray* pAccessors = 0; - CXFA_FMExpression* pList = 0; + std::unique_ptr pAccessors; + std::unique_ptr pList; FX_DWORD line = m_pToken->m_uLinenum; NextToken(); if (m_pToken->m_type != TOKidentifier) { @@ -1097,7 +1005,7 @@ CXFA_FMExpression* CXFA_FMParse::ParseForeachExpression() { ws_TempString.c_str()); NextToken(); } else { - pAccessors = new CFX_PtrArray(); + pAccessors.reset(new CFX_PtrArray()); while (m_pToken->m_type != TOKrparen) { CXFA_FMSimpleExpression* s = ParseSimpleExpression(); if (s) { @@ -1112,42 +1020,30 @@ CXFA_FMExpression* CXFA_FMParse::ParseForeachExpression() { Check(TOKrparen); } Check(TOKdo); - pList = ParseBlockExpression(); + pList.reset(ParseBlockExpression()); Check(TOKendfor); if (m_pErrorInfo->message.IsEmpty()) { - e = new CXFA_FMForeachExpression(line, wsIdentifier, pAccessors, pList); + e.reset(new CXFA_FMForeachExpression( + line, wsIdentifier, pAccessors.release(), pList.release())); } else { if (pAccessors) { - CXFA_FMSimpleExpression* s = 0; - int32_t size = pAccessors->GetSize(); - int32_t index = 0; - while (index < size) { - s = (CXFA_FMSimpleExpression*)pAccessors->GetAt(index); - delete s; - index++; - } - pAccessors->RemoveAll(); - delete pAccessors; - pAccessors = 0; - } - if (pList) { - delete pList; + for (int i = 0; i < pAccessors->GetSize(); ++i) + delete static_cast(pAccessors->GetAt(i)); } } - return e; + return e.release(); } CXFA_FMExpression* CXFA_FMParse::ParseDoExpression() { - CXFA_FMExpression* e = 0; + std::unique_ptr e; FX_DWORD line = m_pToken->m_uLinenum; NextToken(); - e = ParseBlockExpression(); + e.reset(ParseBlockExpression()); Check(TOKend); if (m_pErrorInfo->message.IsEmpty()) { - e = new CXFA_FMDoExpression(line, e); + e.reset(new CXFA_FMDoExpression(line, e.release())); } else { - delete e; - e = 0; + e.reset(); } - return e; + return e.release(); } -- cgit v1.2.3