Move xfa/src up to xfa/.

This CL moves the xfa/src files up to the xfa/ directory and fixes the includes,
include guards, and build files.

R=tsepez@chromium.org

Review URL: https://codereview.chromium.org/1803723002 .

1 files changed, 1051 insertions, 0 deletions

diff --git a/xfa/fxfa/fm2js/xfa_fmparse.cpp b/xfa/fxfa/fm2js/xfa_fmparse.cpp
new file mode 100644
index 0000000000..6e30d95f1a
--- /dev/null
+++ b/xfa/fxfa/fm2js/xfa_fmparse.cpp
@@ -0,0 +1,1051 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "xfa/fxfa/fm2js/xfa_fmparse.h"
+
+#include <memory>
+
+CXFA_FMParse::CXFA_FMParse() : m_pToken(nullptr), m_pErrorInfo(0) {}
+
+int32_t CXFA_FMParse::Init(const CFX_WideStringC& wsFormcalc,
+                           CXFA_FMErrorInfo* pErrorInfo) {
+  m_pErrorInfo = pErrorInfo;
+  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() {
+  std::unique_ptr<CXFA_FMExpression> e;
+  CFX_PtrArray* expression = new CFX_PtrArray();
+  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;
+    }
+
+    if (m_pToken->m_type == TOKfunc) {
+      e.reset(ParseFunction());
+      if (e) {
+        expression->Add(e.release());
+      } else {
+        break;
+      }
+    } else {
+      e.reset(ParseExpression());
+      if (e) {
+        expression->Add(e.release());
+      } else {
+        break;
+      }
+    }
+  }
+  return expression;
+}
+
+CXFA_FMExpression* CXFA_FMParse::ParseFunction() {
+  std::unique_ptr<CXFA_FMExpression> e;
+  CFX_WideStringC ident;
+  std::unique_ptr<CFX_WideStringCArray> pArguments;
+  std::unique_ptr<CFX_PtrArray> pExpressions;
+  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();
+  }
+  Check(TOKlparen);
+  if (m_pToken->m_type == TOKrparen) {
+    NextToken();
+  } else {
+    pArguments.reset(new CFX_WideStringCArray());
+    CFX_WideStringC p;
+    while (1) {
+      if (m_pToken->m_type == TOKidentifier) {
+        p = m_pToken->m_wstring;
+        pArguments->Add(p);
+        NextToken();
+        if (m_pToken->m_type == TOKcomma) {
+          NextToken();
+          continue;
+        } else if (m_pToken->m_type == TOKrparen) {
+          NextToken();
+          break;
+        } else {
+          Check(TOKrparen);
+          break;
+        }
+      } else {
+        CFX_WideString ws_TempString = m_pToken->m_wstring;
+        Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
+              ws_TempString.c_str());
+        NextToken();
+        break;
+      }
+    }
+  }
+  Check(TOKdo);
+  if (m_pToken->m_type == TOKendfunc) {
+    NextToken();
+  } else {
+    pExpressions.reset(ParseTopExpression());
+    Check(TOKendfunc);
+  }
+  if (m_pErrorInfo->message.IsEmpty()) {
+    e.reset(new CXFA_FMFunctionDefinition(line, 0, ident, pArguments.release(),
+                                          pExpressions.release()));
+  } else {
+    if (pArguments)
+      pArguments->RemoveAll();
+    if (pExpressions) {
+      for (int i = 0; i < pExpressions->GetSize(); ++i)
+        delete static_cast<CXFA_FMExpression*>(pExpressions->GetAt(i));
+    }
+  }
+  return e.release();
+}
+
+CXFA_FMExpression* CXFA_FMParse::ParseExpression() {
+  std::unique_ptr<CXFA_FMExpression> e;
+  FX_DWORD line = m_pToken->m_uLinenum;
+  switch (m_pToken->m_type) {
+    case TOKvar:
+      e.reset(ParseVarExpression());
+      break;
+    case TOKnull:
+    case TOKnumber:
+    case TOKstring:
+    case TOKplus:
+    case TOKminus:
+    case TOKksnot:
+    case TOKidentifier:
+    case TOKlparen:
+      e.reset(ParseExpExpression());
+      break;
+    case TOKif:
+      e.reset(ParseIfExpression());
+      break;
+    case TOKwhile:
+      e.reset(ParseWhileExpression());
+      break;
+    case TOKfor:
+      e.reset(ParseForExpression());
+      break;
+    case TOKforeach:
+      e.reset(ParseForeachExpression());
+      break;
+    case TOKdo:
+      e.reset(ParseDoExpression());
+      break;
+    case TOKbreak:
+      e.reset(new CXFA_FMBreakExpression(line));
+      NextToken();
+      break;
+    case TOKcontinue:
+      e.reset(new CXFA_FMContinueExpression(line));
+      NextToken();
+      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.release();
+}
+
+CXFA_FMExpression* CXFA_FMParse::ParseVarExpression() {
+  std::unique_ptr<CXFA_FMExpression> e;
+  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.reset(ParseExpExpression());
+  }
+  if (m_pErrorInfo->message.IsEmpty()) {
+    e.reset(new CXFA_FMVarExpression(line, ident, e.release()));
+  } else {
+    e.reset();
+  }
+  return e.release();
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParseSimpleExpression() {
+  FX_DWORD line = m_pToken->m_uLinenum;
+  std::unique_ptr<CXFA_FMSimpleExpression> pExp1(ParseLogicalOrExpression());
+  while (m_pToken->m_type == TOKassign) {
+    NextToken();
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2(ParseLogicalOrExpression());
+    if (m_pErrorInfo->message.IsEmpty()) {
+      pExp1.reset(new CXFA_FMAssignExpression(line, TOKassign, pExp1.release(),
+                                              pExp2.release()));
+    } else {
+      pExp1.reset();
+    }
+  }
+  return pExp1.release();
+}
+
+CXFA_FMExpression* CXFA_FMParse::ParseExpExpression() {
+  FX_DWORD line = m_pToken->m_uLinenum;
+  std::unique_ptr<CXFA_FMSimpleExpression> pExp1(ParseSimpleExpression());
+  std::unique_ptr<CXFA_FMExpression> e;
+  if (m_pErrorInfo->message.IsEmpty()) {
+    e.reset(new CXFA_FMExpExpression(line, pExp1.release()));
+  } else {
+    e.reset();
+  }
+  return e.release();
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalOrExpression() {
+  FX_DWORD line = m_pToken->m_uLinenum;
+  std::unique_ptr<CXFA_FMSimpleExpression> e1(ParseLogicalAndExpression());
+  for (;;) {
+    switch (m_pToken->m_type) {
+      case TOKor:
+      case TOKksor: {
+        NextToken();
+        std::unique_ptr<CXFA_FMSimpleExpression> e2(
+            ParseLogicalAndExpression());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMLogicalOrExpression(line, TOKor, e1.release(),
+                                                  e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      }
+      default:
+        break;
+    }
+    break;
+  }
+  return e1.release();
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalAndExpression() {
+  FX_DWORD line = m_pToken->m_uLinenum;
+  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());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMLogicalAndExpression(line, TOKand, e1.release(),
+                                                   e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      }
+      default:
+        break;
+    }
+    break;
+  }
+  return e1.release();
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParseEqualityExpression() {
+  FX_DWORD line = m_pToken->m_uLinenum;
+  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());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMEqualityExpression(line, TOKeq, e1.release(),
+                                                 e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKne:
+      case TOKksne:
+        NextToken();
+        e2.reset(ParseRelationalExpression());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMEqualityExpression(line, TOKne, e1.release(),
+                                                 e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      default:
+        break;
+    }
+    break;
+  }
+  return e1.release();
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParseRelationalExpression() {
+  FX_DWORD line = m_pToken->m_uLinenum;
+  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());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMRelationalExpression(line, TOKlt, e1.release(),
+                                                   e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKgt:
+      case TOKksgt:
+        NextToken();
+        e2.reset(ParseAddtiveExpression());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMRelationalExpression(line, TOKgt, e1.release(),
+                                                   e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKle:
+      case TOKksle:
+        NextToken();
+        e2.reset(ParseAddtiveExpression());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMRelationalExpression(line, TOKle, e1.release(),
+                                                   e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKge:
+      case TOKksge:
+        NextToken();
+        e2.reset(ParseAddtiveExpression());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMRelationalExpression(line, TOKge, e1.release(),
+                                                   e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      default:
+        break;
+    }
+    break;
+  }
+  return e1.release();
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParseAddtiveExpression() {
+  FX_DWORD line = m_pToken->m_uLinenum;
+  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());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMAdditiveExpression(line, TOKplus, e1.release(),
+                                                 e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKminus:
+        NextToken();
+        e2.reset(ParseMultiplicativeExpression());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMAdditiveExpression(line, TOKminus, e1.release(),
+                                                 e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      default:
+        break;
+    }
+    break;
+  }
+  return e1.release();
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParseMultiplicativeExpression() {
+  FX_DWORD line = m_pToken->m_uLinenum;
+  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());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMMultiplicativeExpression(
+              line, TOKmul, e1.release(), e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKdiv:
+        NextToken();
+        e2.reset(ParseUnaryExpression());
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1.reset(new CXFA_FMMultiplicativeExpression(
+              line, TOKdiv, e1.release(), e2.release()));
+        } else {
+          e1.reset();
+        }
+        continue;
+      default:
+        break;
+    }
+    break;
+  }
+  return e1.release();
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParseUnaryExpression() {
+  std::unique_ptr<CXFA_FMSimpleExpression> e;
+  FX_DWORD line = m_pToken->m_uLinenum;
+  switch (m_pToken->m_type) {
+    case TOKplus:
+      NextToken();
+      e.reset(ParseUnaryExpression());
+      if (m_pErrorInfo->message.IsEmpty()) {
+        e.reset(new CXFA_FMPosExpression(line, e.release()));
+      } else {
+        e.reset();
+      }
+      break;
+    case TOKminus:
+      NextToken();
+      e.reset(ParseUnaryExpression());
+      if (m_pErrorInfo->message.IsEmpty()) {
+        e.reset(new CXFA_FMNegExpression(line, e.release()));
+      } else {
+        e.reset();
+      }
+      break;
+    case TOKksnot:
+      NextToken();
+      e.reset(ParseUnaryExpression());
+      if (m_pErrorInfo->message.IsEmpty()) {
+        e.reset(new CXFA_FMNotExpression(line, e.release()));
+      } else {
+        e.reset();
+      }
+      break;
+    default:
+      e.reset(ParsePrimaryExpression());
+      break;
+  }
+  return e.release();
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParsePrimaryExpression() {
+  std::unique_ptr<CXFA_FMSimpleExpression> e;
+  FX_DWORD line = m_pToken->m_uLinenum;
+  switch (m_pToken->m_type) {
+    case TOKnumber:
+      e.reset(new CXFA_FMNumberExpression(line, m_pToken->m_wstring));
+      NextToken();
+      break;
+    case TOKstring:
+      e.reset(new 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();
+        if (s) {
+          e.reset(new CXFA_FMDotAccessorExpression(line, NULL, TOKdot,
+                                                   wsIdentifier, s));
+        }
+        NextToken();
+      } else {
+        e.reset(new CXFA_FMIdentifierExpressionn(line, wsIdentifier));
+      }
+    } break;
+    case TOKif:
+      e.reset(new CXFA_FMIdentifierExpressionn(line, m_pToken->m_wstring));
+      NextToken();
+      break;
+    case TOKnull:
+      e.reset(new CXFA_FMNullExpression(line));
+      NextToken();
+      break;
+    case TOKlparen:
+      e.reset(ParseParenExpression());
+      break;
+    default:
+      CFX_WideString ws_TempString = m_pToken->m_wstring;
+      Error(m_pToken->m_uLinenum, FMERR_UNEXPECTED_EXPRESSION,
+            ws_TempString.c_str());
+      NextToken();
+      break;
+  }
+  e.reset(ParsePostExpression(e.release()));
+  if (!(m_pErrorInfo->message.IsEmpty()))
+    e.reset();
+  return e.release();
+}
+
+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();
+        std::unique_ptr<CFX_PtrArray> pArray;
+        if (m_pToken->m_type != TOKrparen) {
+          pArray.reset(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 ||
+                       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()) {
+          e = new CXFA_FMCallExpression(line, e, pArray.release(), FALSE);
+          NextToken();
+          if (m_pToken->m_type != TOKlbracket) {
+            continue;
+          }
+          CXFA_FMSimpleExpression* s = ParseIndexExpression();
+          if (s) {
+            e = new CXFA_FMDotAccessorExpression(line, e, TOKcall,
+                                                 FX_WSTRC(L""), s);
+          } else {
+            delete e;
+            e = nullptr;
+          }
+        } else {
+          if (pArray) {
+            for (int32_t i = 0; i < pArray->GetSize(); ++i)
+              delete static_cast<CXFA_FMSimpleExpression*>(pArray->GetAt(i));
+          }
+          delete e;
+          e = nullptr;
+        }
+      } break;
+      case TOKdot:
+        NextToken();
+        if (m_pToken->m_type == TOKidentifier) {
+          CFX_WideStringC tempStr = m_pToken->m_wstring;
+          FX_DWORD tempLine = m_pToken->m_uLinenum;
+          NextToken();
+          if (m_pToken->m_type == TOKlparen) {
+            CXFA_FMSimpleExpression* pExpAccessor;
+            CXFA_FMSimpleExpression* pExpCall;
+            pExpAccessor = e;
+            NextToken();
+            std::unique_ptr<CFX_PtrArray> pArray;
+            if (m_pToken->m_type != TOKrparen) {
+              pArray.reset(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 ||
+                           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()) {
+              CXFA_FMSimpleExpression* pIdentifier =
+                  new CXFA_FMIdentifierExpressionn(tempLine, tempStr);
+              pExpCall = new CXFA_FMCallExpression(line, pIdentifier,
+                                                   pArray.release(), TRUE);
+              e = new CXFA_FMMethodCallExpression(line, pExpAccessor, pExpCall);
+              NextToken();
+              if (m_pToken->m_type != TOKlbracket) {
+                continue;
+              }
+              CXFA_FMSimpleExpression* s = ParseIndexExpression();
+              if (s) {
+                e = new CXFA_FMDotAccessorExpression(line, e, TOKcall,
+                                                     FX_WSTRC(L""), s);
+              } else {
+                delete e;
+                e = nullptr;
+              }
+            } else {
+              if (pArray) {
+                for (int32_t i = 0; i < pArray->GetSize(); ++i) {
+                  delete static_cast<CXFA_FMSimpleExpression*>(
+                      pArray->GetAt(i));
+                }
+              }
+              delete e;
+              e = nullptr;
+            }
+          } else if (m_pToken->m_type == TOKlbracket) {
+            std::unique_ptr<CXFA_FMSimpleExpression> s(ParseIndexExpression());
+            if (!(m_pErrorInfo->message.IsEmpty())) {
+              delete e;
+              return nullptr;
+            }
+            e = new CXFA_FMDotAccessorExpression(tempLine, e, TOKdot, tempStr,
+                                                 s.release());
+          } else {
+            CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression(
+                tempLine, ACCESSOR_NO_INDEX, NULL, FALSE);
+            e = new CXFA_FMDotAccessorExpression(line, e, TOKdot, tempStr, s);
+            continue;
+          }
+        } else {
+          CFX_WideString ws_TempString = m_pToken->m_wstring;
+          Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
+                ws_TempString.c_str());
+          return e;
+        }
+        break;
+      case TOKdotdot:
+        NextToken();
+        if (m_pToken->m_type == TOKidentifier) {
+          CFX_WideStringC tempStr = m_pToken->m_wstring;
+          FX_DWORD 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;
+              return nullptr;
+            }
+            e = new CXFA_FMDotDotAccessorExpression(tempLine, e, TOKdotdot,
+                                                    tempStr, s.release());
+          } else {
+            CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression(
+                tempLine, ACCESSOR_NO_INDEX, NULL, FALSE);
+            e = new CXFA_FMDotDotAccessorExpression(line, e, TOKdotdot, tempStr,
+                                                    s);
+            continue;
+          }
+        } else {
+          CFX_WideString ws_TempString = m_pToken->m_wstring;
+          Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
+                ws_TempString.c_str());
+          return e;
+        }
+        break;
+      case TOKdotscream:
+        NextToken();
+        if (m_pToken->m_type == TOKidentifier) {
+          CFX_WideStringC tempStr = m_pToken->m_wstring;
+          FX_DWORD 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;
+              return nullptr;
+            }
+            e = new CXFA_FMDotAccessorExpression(tempLine, e, TOKdotscream,
+                                                 tempStr, s.release());
+          } else {
+            CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression(
+                tempLine, ACCESSOR_NO_INDEX, NULL, FALSE);
+            e = new CXFA_FMDotAccessorExpression(line, e, TOKdotscream, tempStr,
+                                                 s);
+            continue;
+          }
+        } else {
+          CFX_WideString ws_TempString = m_pToken->m_wstring;
+          Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
+                ws_TempString.c_str());
+          return e;
+        }
+        break;
+      case TOKdotstar: {
+        CXFA_FMSimpleExpression* s =
+            new CXFA_FMIndexExpression(line, ACCESSOR_NO_INDEX, NULL, FALSE);
+        e = new CXFA_FMDotAccessorExpression(line, e, TOKdotstar,
+                                             FX_WSTRC(L"*"), s);
+      } break;
+      default:
+        return e;
+    }
+    NextToken();
+  }
+  return e;
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParseIndexExpression() {
+  std::unique_ptr<CXFA_FMSimpleExpression> pExp;
+  FX_DWORD 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));
+    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());
+      pExp.reset();
+    }
+    return pExp.release();
+  }
+  if (m_pToken->m_type == TOKplus) {
+    accessorIndex = ACCESSOR_POSITIVE_INDEX;
+    NextToken();
+  } else if (m_pToken->m_type == TOKminus) {
+    accessorIndex = ACCESSOR_NEGATIVE_INDEX;
+    NextToken();
+  }
+  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());
+  } else {
+    pExp.reset(
+        new CXFA_FMIndexExpression(line, accessorIndex, s.release(), FALSE));
+  }
+  return pExp.release();
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParseParenExpression() {
+  Check(TOKlparen);
+
+  if (m_pToken->m_type == TOKrparen) {
+    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_NON_EMPTY_EXPRESSION);
+    NextToken();
+    return nullptr;
+  }
+
+  FX_DWORD line = m_pToken->m_uLinenum;
+  std::unique_ptr<CXFA_FMSimpleExpression> pExp1(ParseLogicalOrExpression());
+
+  while (m_pToken->m_type == TOKassign) {
+    NextToken();
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2(ParseLogicalOrExpression());
+    if (m_pErrorInfo->message.IsEmpty()) {
+      pExp1.reset(new CXFA_FMAssignExpression(line, TOKassign, pExp1.release(),
+                                              pExp2.release()));
+    } else {
+      pExp1.reset();
+    }
+  }
+  Check(TOKrparen);
+  return pExp1.release();
+}
+
+CXFA_FMExpression* CXFA_FMParse::ParseBlockExpression() {
+  FX_DWORD line = m_pToken->m_uLinenum;
+  CXFA_FMExpression* e = nullptr;
+  std::unique_ptr<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) {
+          expression->Add(e);
+        }
+        continue;
+    }
+    break;
+  }
+  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));
+  }
+  return pExp.release();
+}
+
+CXFA_FMExpression* CXFA_FMParse::ParseIfExpression() {
+  FX_DWORD 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());
+    if (m_pToken->m_type != TOKcomma)
+      break;
+    NextToken();
+  }
+  Check(TOKrparen);
+  if (m_pToken->m_type != TOKthen) {
+    m_lexer->SetCurrentLine(line);
+    m_pToken = new CXFA_FMToken(line);
+    m_pToken->m_type = TOKidentifier;
+    m_pToken->m_wstring = FX_WSTRC(L"if");
+    m_lexer->SetToken(m_pToken);
+    m_lexer->RestorePos(pStartPos);
+    return ParseExpExpression();
+  }
+  Check(TOKthen);
+  std::unique_ptr<CXFA_FMExpression> pIfExpression(ParseBlockExpression());
+  std::unique_ptr<CXFA_FMExpression> pElseExpression;
+  switch (m_pToken->m_type) {
+    case TOKeof:
+    case TOKendif:
+      Check(TOKendif);
+      break;
+    case TOKif:
+      pElseExpression.reset(ParseIfExpression());
+      Check(TOKendif);
+      break;
+    case TOKelseif:
+      pElseExpression.reset(ParseIfExpression());
+      break;
+    case TOKelse:
+      NextToken();
+      pElseExpression.reset(ParseBlockExpression());
+      Check(TOKendif);
+      break;
+    default:
+      CFX_WideString ws_TempString = m_pToken->m_wstring;
+      Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IFEND, ws_TempString.c_str());
+      NextToken();
+      break;
+  }
+  std::unique_ptr<CXFA_FMIfExpression> pExp;
+  if (m_pErrorInfo->message.IsEmpty()) {
+    pExp.reset(new CXFA_FMIfExpression(line, pExpression.release(),
+                                       pIfExpression.release(),
+                                       pElseExpression.release()));
+  }
+  return pExp.release();
+}
+
+CXFA_FMExpression* CXFA_FMParse::ParseWhileExpression() {
+  FX_DWORD line = m_pToken->m_uLinenum;
+  NextToken();
+  std::unique_ptr<CXFA_FMSimpleExpression> pCondition(ParseParenExpression());
+  Check(TOKdo);
+  std::unique_ptr<CXFA_FMExpression> pExpression(ParseBlockExpression());
+  Check(TOKendwhile);
+  std::unique_ptr<CXFA_FMExpression> e;
+  if (m_pErrorInfo->message.IsEmpty()) {
+    e.reset(new CXFA_FMWhileExpression(line, pCondition.release(),
+                                       pExpression.release()));
+  }
+  return e.release();
+}
+
+CXFA_FMSimpleExpression* CXFA_FMParse::ParseSubassignmentInForExpression() {
+  std::unique_ptr<CXFA_FMSimpleExpression> e;
+  switch (m_pToken->m_type) {
+    case TOKidentifier:
+      e.reset(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.release();
+}
+
+CXFA_FMExpression* CXFA_FMParse::ParseForExpression() {
+  CFX_WideStringC wsVariant;
+  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,
+          XFA_FM_KeywordToString(m_pToken->m_type), ws_TempString.c_str());
+  }
+  wsVariant = m_pToken->m_wstring;
+  NextToken();
+  std::unique_ptr<CXFA_FMSimpleExpression> pAssignment;
+  if (m_pToken->m_type == TOKassign) {
+    NextToken();
+    pAssignment.reset(ParseSimpleExpression());
+  } else {
+    CFX_WideString ws_TempString = m_pToken->m_wstring;
+    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
+          XFA_FM_KeywordToString(m_pToken->m_type), ws_TempString.c_str());
+  }
+  int32_t iDirection = 0;
+  if (m_pToken->m_type == TOKupto) {
+    iDirection = 1;
+  } else if (m_pToken->m_type == TOKdownto) {
+    iDirection = -1;
+  } else {
+    CFX_WideString ws_TempString = m_pToken->m_wstring;
+    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN, L"upto or downto",
+          (const FX_WCHAR*)ws_TempString);
+  }
+  NextToken();
+  std::unique_ptr<CXFA_FMSimpleExpression> pAccessor(ParseSimpleExpression());
+  std::unique_ptr<CXFA_FMSimpleExpression> pStep;
+  if (m_pToken->m_type == TOKstep) {
+    NextToken();
+    pStep.reset(ParseSimpleExpression());
+  }
+  Check(TOKdo);
+  std::unique_ptr<CXFA_FMExpression> pList(ParseBlockExpression());
+  Check(TOKendfor);
+  std::unique_ptr<CXFA_FMExpression> e;
+  if (m_pErrorInfo->message.IsEmpty()) {
+    e.reset(new CXFA_FMForExpression(line, wsVariant, pAssignment.release(),
+                                     pAccessor.release(), iDirection,
+                                     pStep.release(), pList.release()));
+  }
+  return e.release();
+}
+
+CXFA_FMExpression* CXFA_FMParse::ParseForeachExpression() {
+  std::unique_ptr<CXFA_FMExpression> e;
+  CFX_WideStringC wsIdentifier;
+  std::unique_ptr<CFX_PtrArray> pAccessors;
+  std::unique_ptr<CXFA_FMExpression> pList;
+  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,
+          XFA_FM_KeywordToString(m_pToken->m_type), ws_TempString.c_str());
+  }
+  wsIdentifier = m_pToken->m_wstring;
+  NextToken();
+  Check(TOKin);
+  Check(TOKlparen);
+  if (m_pToken->m_type == TOKrparen) {
+    CFX_WideString ws_TempString = m_pToken->m_wstring;
+    Error(m_pToken->m_uLinenum, FMERR_UNEXPECTED_EXPRESSION,
+          ws_TempString.c_str());
+    NextToken();
+  } else {
+    pAccessors.reset(new CFX_PtrArray());
+    while (m_pToken->m_type != TOKrparen) {
+      CXFA_FMSimpleExpression* s = ParseSimpleExpression();
+      if (s) {
+        pAccessors->Add(s);
+      }
+      if (m_pToken->m_type == TOKcomma) {
+        NextToken();
+      } else {
+        break;
+      }
+    }
+    Check(TOKrparen);
+  }
+  Check(TOKdo);
+  pList.reset(ParseBlockExpression());
+  Check(TOKendfor);
+  if (m_pErrorInfo->message.IsEmpty()) {
+    e.reset(new CXFA_FMForeachExpression(
+        line, wsIdentifier, pAccessors.release(), pList.release()));
+  } else {
+    if (pAccessors) {
+      for (int i = 0; i < pAccessors->GetSize(); ++i)
+        delete static_cast<CXFA_FMSimpleExpression*>(pAccessors->GetAt(i));
+    }
+  }
+  return e.release();
+}
+
+CXFA_FMExpression* CXFA_FMParse::ParseDoExpression() {
+  std::unique_ptr<CXFA_FMExpression> e;
+  FX_DWORD line = m_pToken->m_uLinenum;
+  NextToken();
+  e.reset(ParseBlockExpression());
+  Check(TOKend);
+  if (m_pErrorInfo->message.IsEmpty()) {
+    e.reset(new CXFA_FMDoExpression(line, e.release()));
+  } else {
+    e.reset();
+  }
+  return e.release();
+}