Fix some issues with CXFA_FMParse/CXFA_FMLexer infinite looping.

xfa/src/fxfa/src/fm2js/xfa_fmparse.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa_fm2js.h"
-CXFA_FMParse::CXFA_FMParse() {
-  m_pScript = 0;
-  m_uLength = 0;
-  m_pErrorInfo = 0;
-  m_lexer = 0;
-  m_pToken = 0;
-}
-CXFA_FMParse::~CXFA_FMParse() {
-  if (m_lexer) {
-    delete m_lexer;
-  }
-  m_lexer = 0;
-  m_pErrorInfo = 0;
-  m_pScript = 0;
-  m_pToken = 0;
-}
+
+CXFA_FMParse::CXFA_FMParse() : m_pToken(nullptr), m_pErrorInfo(0) {}
+
 int32_t CXFA_FMParse::Init(const CFX_WideStringC& wsFormcalc,
                            CXFA_FMErrorInfo* pErrorInfo) {
-  m_pScript = wsFormcalc.GetPtr();
-  m_uLength = wsFormcalc.GetLength();
   m_pErrorInfo = pErrorInfo;
-  m_lexer = new CXFA_FMLexer(wsFormcalc, m_pErrorInfo);
-  if (m_lexer == 0) {
-    return -1;
-  }
+  m_lexer.reset(new CXFA_FMLexer(wsFormcalc, m_pErrorInfo));
   return 0;
 }
+
 void CXFA_FMParse::NextToken() {
   m_pToken = m_lexer->NextToken();
   while (m_pToken->m_type == TOKreserver) {
     if (m_lexer->HasError()) {
       break;
     }
     m_pToken = m_lexer->NextToken();
   }
 }
+
 void CXFA_FMParse::Check(XFA_FM_TOKEN op) {
   if (m_pToken->m_type != op) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
     Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
           XFA_FM_KeywordToString(op), ws_TempString.c_str());
   }
   NextToken();
 }
+
 void CXFA_FMParse::Error(FX_DWORD lineNum, XFA_FM_ERRMSG msg, ...) {
   m_pErrorInfo->linenum = lineNum;
   const FX_WCHAR* lpMessageInfo = XFA_FM_ErrorMsg(msg);
   va_list ap;
   va_start(ap, msg);
   m_pErrorInfo->message.FormatV(lpMessageInfo, ap);
   va_end(ap);
 }
+
 CFX_PtrArray* CXFA_FMParse::ParseTopExpression() {
   CXFA_FMExpression* e = 0;
   CFX_PtrArray* expression = new CFX_PtrArray();
   while (1) {
     if (m_pToken->m_type == TOKeof) {

[Tom Sepez, 2016/02/18 00:39:14]

nit: combine with || while you're at it.

[Oliver Chang, 2016/02/18 00:49:02]

Done.

       return expression;
     }
     if (m_pToken->m_type == TOKendfunc) {
       return expression;
     }
     if (m_pToken->m_type == TOKendif) {
       return expression;
     }
     if (m_pToken->m_type == TOKelseif) {
       return expression;
     }
     if (m_pToken->m_type == TOKelse) {
       return expression;
     }
+    if (m_pToken->m_type == TOKreserver) {
+      return expression;
+    }
+
     if (m_pToken->m_type == TOKfunc) {
       e = ParseFunction();
       if (e) {
         expression->Add(e);
       } else {
         break;
       }
     } else {
       e = ParseExpression();
       if (e) {
         expression->Add(e);
       } else {
         break;
       }
     }
   }
   return expression;
 }
+
 CXFA_FMExpression* CXFA_FMParse::ParseFunction() {
   CXFA_FMExpression* e = 0;
   CFX_WideStringC ident;
   CFX_WideStringCArray* pArguments = 0;
   CFX_PtrArray* pExpressions = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
     Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
@@ skipping 58 matching lines @@
         delete e1;
         index++;
       }
       pExpressions->RemoveAll();
       delete pExpressions;
       pExpressions = 0;
     }
   }
   return e;
 }
+
 CXFA_FMExpression* CXFA_FMParse::ParseExpression() {
   CXFA_FMExpression* e = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   switch (m_pToken->m_type) {
     case TOKvar:
       e = ParseVarExpression();
       break;
     case TOKnull:
     case TOKnumber:
     case TOKstring:
@@ skipping 29 matching lines @@
       break;
     default:
       CFX_WideString ws_TempString = m_pToken->m_wstring;
       Error(m_pToken->m_uLinenum, FMERR_UNEXPECTED_EXPRESSION,
             ws_TempString.c_str());
       NextToken();
       break;
   }
   return e;
 }
+
 CXFA_FMExpression* CXFA_FMParse::ParseVarExpression() {
   CXFA_FMExpression* e = 0;
   CFX_WideStringC ident;
   FX_DWORD line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
     Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
           ws_TempString.c_str());
   } else {
     ident = m_pToken->m_wstring;
     NextToken();
   }
   if (m_pToken->m_type == TOKassign) {
     NextToken();
     e = ParseExpExpression();
   }
   if (m_pErrorInfo->message.IsEmpty()) {
     e = new CXFA_FMVarExpression(line, ident, e);
   } else {
     delete e;
     e = 0;
   }
   return e;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseSimpleExpression() {
   FX_DWORD line = m_pToken->m_uLinenum;
   CXFA_FMSimpleExpression *pExp1 = 0, *pExp2 = 0;
   pExp1 = ParseLogicalOrExpression();
   while (m_pToken->m_type == TOKassign) {
     NextToken();
     pExp2 = ParseLogicalOrExpression();
     if (m_pErrorInfo->message.IsEmpty()) {
       pExp1 = new CXFA_FMAssignExpression(line, TOKassign, pExp1, pExp2);
     } else {
       delete pExp1;
       pExp1 = 0;
     }
   }
   return pExp1;
 }
+
 CXFA_FMExpression* CXFA_FMParse::ParseExpExpression() {
   CXFA_FMExpression* e = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   CXFA_FMSimpleExpression* pExp1 = 0;
   pExp1 = ParseSimpleExpression();
   if (m_pErrorInfo->message.IsEmpty()) {
     e = new CXFA_FMExpExpression(line, pExp1);
   } else {
     delete pExp1;
     e = 0;
   }
   return e;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalOrExpression() {
   CXFA_FMSimpleExpression *e1 = 0, *e2 = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   e1 = ParseLogicalAndExpression();
   for (;;) {
     switch (m_pToken->m_type) {
       case TOKor:
       case TOKksor:
         NextToken();
         e2 = ParseLogicalAndExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = new CXFA_FMLogicalOrExpression(line, TOKor, e1, e2);
         } else {
           delete e1;
           e1 = 0;
         }
         continue;
       default:
         break;
     }
     break;
   }
   return e1;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalAndExpression() {
   CXFA_FMSimpleExpression *e1 = 0, *e2 = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   e1 = ParseEqualityExpression();
   for (;;) {
     switch (m_pToken->m_type) {
       case TOKand:
       case TOKksand:
         NextToken();
         e2 = ParseEqualityExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = new CXFA_FMLogicalAndExpression(line, TOKand, e1, e2);
         } else {
           delete e1;
           e1 = 0;
         }
         continue;
       default:
         break;
     }
     break;
   }
   return e1;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseEqualityExpression() {
   CXFA_FMSimpleExpression *e1 = 0, *e2 = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   e1 = ParseRelationalExpression();
   for (;;) {
     switch (m_pToken->m_type) {
       case TOKeq:
       case TOKkseq:
         NextToken();
         e2 = ParseRelationalExpression();
@@ skipping 15 matching lines @@
           e1 = 0;
         }
         continue;
       default:
         break;
     }
     break;
   }
   return e1;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseRelationalExpression() {
   CXFA_FMSimpleExpression *e1 = 0, *e2 = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   e1 = ParseAddtiveExpression();
   for (;;) {
     switch (m_pToken->m_type) {
       case TOKlt:
       case TOKkslt:
         NextToken();
         e2 = ParseAddtiveExpression();
@@ skipping 37 matching lines @@
           e1 = 0;
         }
         continue;
       default:
         break;
     }
     break;
   }
   return e1;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseAddtiveExpression() {
   CXFA_FMSimpleExpression *e1 = 0, *e2 = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   e1 = ParseMultiplicativeExpression();
   for (;;) {
     switch (m_pToken->m_type) {
       case TOKplus:
         NextToken();
         e2 = ParseMultiplicativeExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
@@ skipping 13 matching lines @@
           e1 = 0;
         }
         continue;
       default:
         break;
     }
     break;
   }
   return e1;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseMultiplicativeExpression() {
   CXFA_FMSimpleExpression *e1 = 0, *e2 = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   e1 = ParseUnaryExpression();
   for (;;) {
     switch (m_pToken->m_type) {
       case TOKmul:
         NextToken();
         e2 = ParseUnaryExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
@@ skipping 13 matching lines @@
           e1 = 0;
         }
         continue;
       default:
         break;
     }
     break;
   }
   return e1;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseUnaryExpression() {
   CXFA_FMSimpleExpression* e = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   switch (m_pToken->m_type) {
     case TOKplus:
       NextToken();
       e = ParseUnaryExpression();
       if (m_pErrorInfo->message.IsEmpty()) {
         e = new CXFA_FMPosExpression(line, e);
       } else {
@@ skipping 17 matching lines @@
       } else {
         e = 0;
       }
       break;
     default:
       e = ParsePrimaryExpression();
       break;
   }
   return e;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParsePrimaryExpression() {
   CXFA_FMSimpleExpression* e = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   switch (m_pToken->m_type) {
     case TOKnumber:
       e = new CXFA_FMNumberExpression(line, m_pToken->m_wstring);
       NextToken();
       break;
     case TOKstring:
       e = new CXFA_FMStringExpression(line, m_pToken->m_wstring);
@@ skipping 31 matching lines @@
       NextToken();
       break;
   }
   e = ParsePostExpression(e);
   if (!(m_pErrorInfo->message.IsEmpty())) {
     delete e;
     e = 0;
   }
   return e;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression(
     CXFA_FMSimpleExpression* e) {
   FX_DWORD line = m_pToken->m_uLinenum;
   while (1) {
     switch (m_pToken->m_type) {
       case TOKlparen: {
         NextToken();
         CFX_PtrArray* pArray = 0;
         if (m_pToken->m_type != TOKrparen) {
           pArray = new CFX_PtrArray();
           while (m_pToken->m_type != TOKrparen) {
             CXFA_FMSimpleExpression* e = ParseSimpleExpression();
             if (e) {
               pArray->Add(e);
             }
             if (m_pToken->m_type == TOKcomma) {
               NextToken();
-            } else if (m_pToken->m_type == TOKeof) {
+            } else if (m_pToken->m_type == TOKeof ||
+                       m_pToken->m_type == TOKreserver) {
               break;
             }
           }
           if (m_pToken->m_type != TOKrparen) {
             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 (m_pErrorInfo->message.IsEmpty()) {
@@ skipping 34 matching lines @@
             pExpAccessor = e;
             NextToken();
             CFX_PtrArray* pArray = 0;
             if (m_pToken->m_type != TOKrparen) {
               pArray = new CFX_PtrArray();
               while (m_pToken->m_type != TOKrparen) {
                 CXFA_FMSimpleExpression* exp = ParseSimpleExpression();
                 pArray->Add(exp);
                 if (m_pToken->m_type == TOKcomma) {
                   NextToken();
-                } else if (m_pToken->m_type == TOKeof) {
+                } else if (m_pToken->m_type == TOKeof ||
+                           m_pToken->m_type == TOKreserver) {
                   break;
                 }
               }
               if (m_pToken->m_type != TOKrparen) {
                 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 (m_pErrorInfo->message.IsEmpty()) {
@@ skipping 129 matching lines @@
         e = new CXFA_FMDotAccessorExpression(line, e, TOKdotstar,
                                              FX_WSTRC(L"*"), s);
       } break;
       default:
         return e;
     }
     NextToken();
   }
   return e;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseIndexExpression() {
   CXFA_FMSimpleExpression* pExp = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   NextToken();
   CXFA_FMSimpleExpression* s = 0;
   XFA_FM_AccessorIndex accessorIndex = ACCESSOR_NO_RELATIVEINDEX;
   if (m_pToken->m_type == TOKmul) {
     pExp = new CXFA_FMIndexExpression(line, accessorIndex, s, TRUE);
     NextToken();
     if (m_pToken->m_type != TOKrbracket) {
@@ skipping 20 matching lines @@
     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);
   }
   return pExp;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseParenExpression() {
   CXFA_FMSimpleExpression *pExp1 = 0, *pExp2 = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   Check(TOKlparen);
   if (m_pToken->m_type != TOKrparen) {
     pExp1 = ParseLogicalOrExpression();
     while (m_pToken->m_type == TOKassign) {
       NextToken();
       pExp2 = ParseLogicalOrExpression();
       if (m_pErrorInfo->message.IsEmpty()) {
         pExp1 = new CXFA_FMAssignExpression(line, TOKassign, pExp1, pExp2);
       } else {
         delete pExp1;
         pExp1 = 0;
       }
     }
     Check(TOKrparen);
   } else {
     NextToken();
   }
   return pExp1;
 }
+
 CXFA_FMExpression* CXFA_FMParse::ParseBlockExpression() {
   FX_DWORD line = m_pToken->m_uLinenum;
   CXFA_FMExpression* e = 0;
   CFX_PtrArray* expression = new CFX_PtrArray();
   while (1) {
     switch (m_pToken->m_type) {
       case TOKeof:
       case TOKendif:
       case TOKelseif:
       case TOKelse:
       case TOKendwhile:
       case TOKendfor:
       case TOKend:
       case TOKendfunc:
+      case TOKreserver:
         break;
       case TOKfunc:
         e = ParseFunction();
         if (e) {
           expression->Add(e);
         }
         continue;
       default:
         e = ParseExpression();
         if (e) {
@@ skipping 13 matching lines @@
       e = (CXFA_FMExpression*)expression->GetAt(index);
       delete e;
       index++;
     }
     expression->RemoveAll();
     delete expression;
     expression = 0;
   }
   return pExp;
 }
+
 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);
   while (m_pToken->m_type != TOKrparen) {
     if (pExpression) {
@@ skipping 54 matching lines @@
     }
     if (pIfExpression) {
       delete pIfExpression;
     }
     if (pElseExpression) {
       delete pElseExpression;
     }
   }
   return pExp;
 }
+
 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();
   Check(TOKdo);
   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);
   }
   return e;
 }
+
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseSubassignmentInForExpression() {
   CXFA_FMSimpleExpression* e = 0;
   switch (m_pToken->m_type) {
     case TOKidentifier:
       e = ParseSimpleExpression();
       break;
     default:
       CFX_WideString ws_TempString = m_pToken->m_wstring;
       Error(m_pToken->m_uLinenum, FMERR_UNEXPECTED_EXPRESSION,
             ws_TempString.c_str());
       NextToken();
       break;
   }
   return e;
 }
+
 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) {
@@ skipping 42 matching lines @@
     }
     if (pStep) {
       delete pStep;
     }
     if (pList) {
       delete pList;
     }
   }
   return e;
 }
+
 CXFA_FMExpression* CXFA_FMParse::ParseForeachExpression() {
   CXFA_FMExpression* e = 0;
   CFX_WideStringC wsIdentifier;
   CFX_PtrArray* pAccessors = 0;
   CXFA_FMExpression* pList = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
     Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
@@ skipping 41 matching lines @@
       pAccessors->RemoveAll();
       delete pAccessors;
       pAccessors = 0;
     }
     if (pList) {
       delete pList;
     }
   }
   return e;
 }
+
 CXFA_FMExpression* CXFA_FMParse::ParseDoExpression() {
   CXFA_FMExpression* e = 0;
   FX_DWORD line = m_pToken->m_uLinenum;
   NextToken();
   e = ParseBlockExpression();
   Check(TOKend);
   if (m_pErrorInfo->message.IsEmpty()) {
     e = new CXFA_FMDoExpression(line, e);
   } else {
     delete e;
     e = 0;
   }
   return e;
 }