Rename formcalc files to better match contents

Most files match the contents. The expression files are named to match
their base type even though they contain all the expression
subclasses.

Change-Id: I3b7705c7b206a9fa1afae8b677f765e8b788e84d
Reviewed-on: https://pdfium-review.googlesource.com/5492
Commit-Queue: dsinclair <dsinclair@chromium.org>
Reviewed-by: Nicolás Peña <npm@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>

1 files changed, 998 insertions, 0 deletions

diff --git a/xfa/fxfa/fm2js/cxfa_fmparse.cpp b/xfa/fxfa/fm2js/cxfa_fmparse.cpp
new file mode 100644
index 0000000000..cac7ad1b59
--- /dev/null
+++ b/xfa/fxfa/fm2js/cxfa_fmparse.cpp
@@ -0,0 +1,998 @@
+// 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/cxfa_fmparse.h"
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "third_party/base/ptr_util.h"
+
+namespace {
+
+const int kMaxAssignmentChainLength = 12;
+
+}  // namespace
+
+CXFA_FMParse::CXFA_FMParse(const CFX_WideStringC& wsFormcalc,
+                           CXFA_FMErrorInfo* pErrorInfo)
+    : m_pToken(nullptr), m_pErrorInfo(pErrorInfo) {
+  m_lexer = pdfium::MakeUnique<CXFA_FMLexer>(wsFormcalc, m_pErrorInfo);
+}
+
+CXFA_FMParse::~CXFA_FMParse() {}
+
+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) {
+    Error(kFMErrExpectedToken, XFA_FM_KeywordToString(op),
+          m_pToken->m_wstring.c_str());
+  }
+  NextToken();
+}
+
+void CXFA_FMParse::Error(const wchar_t* msg, ...) {
+  m_pErrorInfo->linenum = m_pToken->m_uLinenum;
+  va_list ap;
+  va_start(ap, msg);
+  m_pErrorInfo->message.FormatV(msg, ap);
+  va_end(ap);
+  ASSERT(!m_pErrorInfo->message.IsEmpty());
+}
+
+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 expressions;
+    }
+
+    expr = m_pToken->m_type == TOKfunc ? ParseFunction() : ParseExpression();
+    if (!expr)
+      break;
+    expressions.push_back(std::move(expr));
+  }
+  return expressions;
+}
+
+std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseFunction() {
+  CFX_WideStringC ident;
+  std::vector<CFX_WideStringC> arguments;
+  std::vector<std::unique_ptr<CXFA_FMExpression>> expressions;
+  uint32_t line = m_pToken->m_uLinenum;
+  NextToken();
+  if (m_pToken->m_type != TOKidentifier) {
+    Error(kFMErrExpectedIdentifier, m_pToken->m_wstring.c_str());
+  } else {
+    ident = m_pToken->m_wstring;
+    NextToken();
+  }
+  Check(TOKlparen);
+  if (m_pToken->m_type == TOKrparen) {
+    NextToken();
+  } else {
+    while (1) {
+      if (m_pToken->m_type == TOKidentifier) {
+        arguments.push_back(m_pToken->m_wstring);
+        NextToken();
+        if (m_pToken->m_type == TOKcomma) {
+          NextToken();
+          continue;
+        }
+        if (m_pToken->m_type == TOKrparen)
+          NextToken();
+        else
+          Check(TOKrparen);
+      } else {
+        Error(kFMErrExpectedIdentifier, m_pToken->m_wstring.c_str());
+        NextToken();
+      }
+      break;
+    }
+  }
+  Check(TOKdo);
+  if (m_pToken->m_type == TOKendfunc) {
+    NextToken();
+  } else {
+    expressions = ParseTopExpression();
+    Check(TOKendfunc);
+  }
+  if (HasError())
+    return nullptr;
+
+  return pdfium::MakeUnique<CXFA_FMFunctionDefinition>(
+      line, false, ident, std::move(arguments), std::move(expressions));
+}
+
+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:
+      expr = ParseVarExpression();
+      break;
+    case TOKnull:
+    case TOKnumber:
+    case TOKstring:
+    case TOKplus:
+    case TOKminus:
+    case TOKksnot:
+    case TOKidentifier:
+    case TOKlparen:
+      expr = ParseExpExpression();
+      break;
+    case TOKif:
+      expr = ParseIfExpression();
+      break;
+    case TOKwhile:
+      expr = ParseWhileExpression();
+      break;
+    case TOKfor:
+      expr = ParseForExpression();
+      break;
+    case TOKforeach:
+      expr = ParseForeachExpression();
+      break;
+    case TOKdo:
+      expr = ParseDoExpression();
+      break;
+    case TOKbreak:
+      expr = pdfium::MakeUnique<CXFA_FMBreakExpression>(line);
+      NextToken();
+      break;
+    case TOKcontinue:
+      expr = pdfium::MakeUnique<CXFA_FMContinueExpression>(line);
+      NextToken();
+      break;
+    default:
+      Error(kFMErrUnexpectedExpression, m_pToken->m_wstring.c_str());
+      NextToken();
+      break;
+  }
+  return expr;
+}
+
+std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseVarExpression() {
+  CFX_WideStringC ident;
+  uint32_t line = m_pToken->m_uLinenum;
+  NextToken();
+  if (m_pToken->m_type != TOKidentifier) {
+    Error(kFMErrExpectedIdentifier, m_pToken->m_wstring.c_str());
+  } else {
+    ident = m_pToken->m_wstring;
+    NextToken();
+  }
+  std::unique_ptr<CXFA_FMExpression> expr;
+  if (m_pToken->m_type == TOKassign) {
+    NextToken();
+    expr = ParseExpExpression();
+  }
+  if (HasError())
+    return nullptr;
+
+  return pdfium::MakeUnique<CXFA_FMVarExpression>(line, ident, std::move(expr));
+}
+
+std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseSimpleExpression() {
+  uint32_t line = m_pToken->m_uLinenum;
+  std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression();
+  int level = 1;
+  while (m_pToken->m_type == TOKassign) {
+    NextToken();
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2 = ParseLogicalOrExpression();
+    if (level++ == kMaxAssignmentChainLength)
+      Error(kFMErrLongAssignmentChain);
+    if (m_pErrorInfo->message.IsEmpty()) {
+      pExp1 = pdfium::MakeUnique<CXFA_FMAssignExpression>(
+          line, TOKassign, std::move(pExp1), std::move(pExp2));
+    } else {
+      pExp1.reset();
+    }
+  }
+  return pExp1;
+}
+
+std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseExpExpression() {
+  uint32_t line = m_pToken->m_uLinenum;
+  std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseSimpleExpression();
+  if (HasError())
+    return nullptr;
+
+  return pdfium::MakeUnique<CXFA_FMExpExpression>(line, std::move(pExp1));
+}
+
+std::unique_ptr<CXFA_FMSimpleExpression>
+CXFA_FMParse::ParseLogicalOrExpression() {
+  uint32_t 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 = pdfium::MakeUnique<CXFA_FMLogicalOrExpression>(
+              line, TOKor, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      }
+      default:
+        break;
+    }
+    break;
+  }
+  return e1;
+}
+
+std::unique_ptr<CXFA_FMSimpleExpression>
+CXFA_FMParse::ParseLogicalAndExpression() {
+  uint32_t 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 = pdfium::MakeUnique<CXFA_FMLogicalAndExpression>(
+              line, TOKand, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      }
+      default:
+        break;
+    }
+    break;
+  }
+  return e1;
+}
+
+std::unique_ptr<CXFA_FMSimpleExpression>
+CXFA_FMParse::ParseEqualityExpression() {
+  uint32_t 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 = ParseRelationalExpression();
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1 = pdfium::MakeUnique<CXFA_FMEqualityExpression>(
+              line, TOKeq, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKne:
+      case TOKksne:
+        NextToken();
+        e2 = ParseRelationalExpression();
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1 = pdfium::MakeUnique<CXFA_FMEqualityExpression>(
+              line, TOKne, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      default:
+        break;
+    }
+    break;
+  }
+  return e1;
+}
+
+std::unique_ptr<CXFA_FMSimpleExpression>
+CXFA_FMParse::ParseRelationalExpression() {
+  uint32_t 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 = ParseAddtiveExpression();
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>(
+              line, TOKlt, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKgt:
+      case TOKksgt:
+        NextToken();
+        e2 = ParseAddtiveExpression();
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>(
+              line, TOKgt, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKle:
+      case TOKksle:
+        NextToken();
+        e2 = ParseAddtiveExpression();
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>(
+              line, TOKle, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKge:
+      case TOKksge:
+        NextToken();
+        e2 = ParseAddtiveExpression();
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>(
+              line, TOKge, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      default:
+        break;
+    }
+    break;
+  }
+  return e1;
+}
+
+std::unique_ptr<CXFA_FMSimpleExpression>
+CXFA_FMParse::ParseAddtiveExpression() {
+  uint32_t 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 = ParseMultiplicativeExpression();
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1 = pdfium::MakeUnique<CXFA_FMAdditiveExpression>(
+              line, TOKplus, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKminus:
+        NextToken();
+        e2 = ParseMultiplicativeExpression();
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1 = pdfium::MakeUnique<CXFA_FMAdditiveExpression>(
+              line, TOKminus, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      default:
+        break;
+    }
+    break;
+  }
+  return e1;
+}
+
+std::unique_ptr<CXFA_FMSimpleExpression>
+CXFA_FMParse::ParseMultiplicativeExpression() {
+  uint32_t 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 = ParseUnaryExpression();
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1 = pdfium::MakeUnique<CXFA_FMMultiplicativeExpression>(
+              line, TOKmul, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      case TOKdiv:
+        NextToken();
+        e2 = ParseUnaryExpression();
+        if (m_pErrorInfo->message.IsEmpty()) {
+          e1 = pdfium::MakeUnique<CXFA_FMMultiplicativeExpression>(
+              line, TOKdiv, std::move(e1), std::move(e2));
+        } else {
+          e1.reset();
+        }
+        continue;
+      default:
+        break;
+    }
+    break;
+  }
+  return e1;
+}
+
+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();
+      expr = ParseUnaryExpression();
+      if (m_pErrorInfo->message.IsEmpty())
+        expr = pdfium::MakeUnique<CXFA_FMPosExpression>(line, std::move(expr));
+      else
+        expr.reset();
+      break;
+    case TOKminus:
+      NextToken();
+      expr = ParseUnaryExpression();
+      if (m_pErrorInfo->message.IsEmpty())
+        expr = pdfium::MakeUnique<CXFA_FMNegExpression>(line, std::move(expr));
+      else
+        expr.reset();
+      break;
+    case TOKksnot:
+      NextToken();
+      expr = ParseUnaryExpression();
+      if (m_pErrorInfo->message.IsEmpty())
+        expr = pdfium::MakeUnique<CXFA_FMNotExpression>(line, std::move(expr));
+      else
+        expr.reset();
+      break;
+    default:
+      expr = ParsePrimaryExpression();
+      break;
+  }
+  return expr;
+}
+
+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:
+      expr = pdfium::MakeUnique<CXFA_FMNumberExpression>(line,
+                                                         m_pToken->m_wstring);
+      NextToken();
+      break;
+    case TOKstring:
+      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) {
+        std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
+        if (s) {
+          expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
+              line, nullptr, TOKdot, wsIdentifier, std::move(s));
+        }
+        NextToken();
+      } else {
+        expr =
+            pdfium::MakeUnique<CXFA_FMIdentifierExpression>(line, wsIdentifier);
+      }
+      break;
+    }
+    case TOKif:
+      expr = pdfium::MakeUnique<CXFA_FMIdentifierExpression>(
+          line, m_pToken->m_wstring);
+      NextToken();
+      break;
+    case TOKnull:
+      expr = pdfium::MakeUnique<CXFA_FMNullExpression>(line);
+      NextToken();
+      break;
+    case TOKlparen:
+      expr = ParseParenExpression();
+      break;
+    default:
+      Error(kFMErrUnexpectedExpression, m_pToken->m_wstring.c_str());
+      NextToken();
+      break;
+  }
+  expr = ParsePostExpression(std::move(expr));
+  if (HasError())
+    expr.reset();
+  return expr;
+}
+
+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::vector<std::unique_ptr<CXFA_FMSimpleExpression>> expressions;
+        if (m_pToken->m_type != TOKrparen) {
+          while (m_pToken->m_type != TOKrparen) {
+            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 ||
+                       m_pToken->m_type == TOKreserver) {
+              break;
+            }
+          }
+          if (m_pToken->m_type != TOKrparen) {
+            Error(kFMErrExpectedToken, XFA_FM_KeywordToString(TOKrparen),
+                  m_pToken->m_wstring.c_str());
+          }
+        }
+        if (m_pErrorInfo->message.IsEmpty()) {
+          expr = pdfium::MakeUnique<CXFA_FMCallExpression>(
+              line, std::move(expr), std::move(expressions), false);
+          NextToken();
+          if (m_pToken->m_type != TOKlbracket)
+            continue;
+
+          std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
+          if (s) {
+            expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
+                line, std::move(expr), TOKcall, L"", std::move(s));
+          } else {
+            expr.reset();
+          }
+        } else {
+          expr.reset();
+        }
+        break;
+      }
+      case TOKdot:
+        NextToken();
+        if (m_pToken->m_type == TOKidentifier) {
+          CFX_WideStringC tempStr = m_pToken->m_wstring;
+          uint32_t tempLine = m_pToken->m_uLinenum;
+          NextToken();
+          if (m_pToken->m_type == TOKlparen) {
+            std::unique_ptr<CXFA_FMSimpleExpression> pExpCall;
+            NextToken();
+            std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> expressions;
+            if (m_pToken->m_type != TOKrparen) {
+              while (m_pToken->m_type != TOKrparen) {
+                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 ||
+                           m_pToken->m_type == TOKreserver) {
+                  break;
+                }
+              }
+              if (m_pToken->m_type != TOKrparen) {
+                Error(kFMErrExpectedToken, XFA_FM_KeywordToString(TOKrparen),
+                      m_pToken->m_wstring.c_str());
+              }
+            }
+            if (m_pErrorInfo->message.IsEmpty()) {
+              std::unique_ptr<CXFA_FMSimpleExpression> pIdentifier =
+                  pdfium::MakeUnique<CXFA_FMIdentifierExpression>(tempLine,
+                                                                  tempStr);
+              pExpCall = pdfium::MakeUnique<CXFA_FMCallExpression>(
+                  line, std::move(pIdentifier), std::move(expressions), true);
+              expr = pdfium::MakeUnique<CXFA_FMMethodCallExpression>(
+                  line, std::move(expr), std::move(pExpCall));
+              NextToken();
+              if (m_pToken->m_type != TOKlbracket)
+                continue;
+
+              std::unique_ptr<CXFA_FMSimpleExpression> s =
+                  ParseIndexExpression();
+              if (s) {
+                expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
+                    line, std::move(expr), TOKcall, L"", std::move(s));
+              } else {
+                expr.reset();
+              }
+            } else {
+              expr.reset();
+            }
+          } else if (m_pToken->m_type == TOKlbracket) {
+            std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
+            if (HasError())
+              return nullptr;
+
+            expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
+                tempLine, std::move(expr), TOKdot, tempStr, std::move(s));
+          } else {
+            std::unique_ptr<CXFA_FMSimpleExpression> s =
+                pdfium::MakeUnique<CXFA_FMIndexExpression>(
+                    tempLine, ACCESSOR_NO_INDEX, nullptr, false);
+            expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
+                line, std::move(expr), TOKdot, tempStr, std::move(s));
+            continue;
+          }
+        } else {
+          Error(kFMErrExpectedIdentifier, m_pToken->m_wstring.c_str());
+          return expr;
+        }
+        break;
+      case TOKdotdot:
+        NextToken();
+        if (m_pToken->m_type == TOKidentifier) {
+          CFX_WideStringC tempStr = m_pToken->m_wstring;
+          uint32_t tempLine = m_pToken->m_uLinenum;
+          NextToken();
+          if (m_pToken->m_type == TOKlbracket) {
+            std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
+            if (HasError())
+              return nullptr;
+
+            expr = pdfium::MakeUnique<CXFA_FMDotDotAccessorExpression>(
+                tempLine, std::move(expr), TOKdotdot, tempStr, std::move(s));
+          } else {
+            std::unique_ptr<CXFA_FMSimpleExpression> s =
+                pdfium::MakeUnique<CXFA_FMIndexExpression>(
+                    tempLine, ACCESSOR_NO_INDEX, nullptr, false);
+            expr = pdfium::MakeUnique<CXFA_FMDotDotAccessorExpression>(
+                line, std::move(expr), TOKdotdot, tempStr, std::move(s));
+            continue;
+          }
+        } else {
+          Error(kFMErrExpectedIdentifier, m_pToken->m_wstring.c_str());
+          return expr;
+        }
+        break;
+      case TOKdotscream: {
+        NextToken();
+        if (m_pToken->m_type != TOKidentifier) {
+          Error(kFMErrExpectedIdentifier, m_pToken->m_wstring.c_str());
+          return expr;
+        }
+        CFX_WideStringC tempStr = m_pToken->m_wstring;
+        uint32_t tempLine = m_pToken->m_uLinenum;
+        NextToken();
+        if (m_pToken->m_type != TOKlbracket) {
+          std::unique_ptr<CXFA_FMSimpleExpression> s =
+              pdfium::MakeUnique<CXFA_FMIndexExpression>(
+                  tempLine, ACCESSOR_NO_INDEX, nullptr, false);
+          expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
+              line, std::move(expr), TOKdotscream, tempStr, std::move(s));
+          continue;
+        }
+        std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
+        if (HasError())
+          return nullptr;
+
+        expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
+            tempLine, std::move(expr), TOKdotscream, tempStr, std::move(s));
+        break;
+      }
+      case TOKdotstar: {
+        std::unique_ptr<CXFA_FMSimpleExpression> s =
+            pdfium::MakeUnique<CXFA_FMIndexExpression>(line, ACCESSOR_NO_INDEX,
+                                                       nullptr, false);
+        expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
+            line, std::move(expr), TOKdotstar, L"*", std::move(s));
+        break;
+      }
+      default:
+        return expr;
+    }
+    NextToken();
+  }
+  return expr;
+}
+
+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 = pdfium::MakeUnique<CXFA_FMIndexExpression>(line, accessorIndex,
+                                                      std::move(s), true);
+    NextToken();
+    if (m_pToken->m_type != TOKrbracket) {
+      Error(kFMErrExpectedToken, XFA_FM_KeywordToString(TOKrparen),
+            m_pToken->m_wstring.c_str());
+      pExp.reset();
+    }
+    return pExp;
+  }
+  if (m_pToken->m_type == TOKplus) {
+    accessorIndex = ACCESSOR_POSITIVE_INDEX;
+    NextToken();
+  } else if (m_pToken->m_type == TOKminus) {
+    accessorIndex = ACCESSOR_NEGATIVE_INDEX;
+    NextToken();
+  }
+  s = ParseSimpleExpression();
+  if (m_pToken->m_type != TOKrbracket) {
+    Error(kFMErrExpectedToken, XFA_FM_KeywordToString(TOKrparen),
+          m_pToken->m_wstring.c_str());
+  } else {
+    pExp = pdfium::MakeUnique<CXFA_FMIndexExpression>(line, accessorIndex,
+                                                      std::move(s), false);
+  }
+  return pExp;
+}
+
+std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseParenExpression() {
+  Check(TOKlparen);
+
+  if (m_pToken->m_type == TOKrparen) {
+    Error(kFMErrExpectedNonEmptyExpression);
+    NextToken();
+    return nullptr;
+  }
+
+  uint32_t line = m_pToken->m_uLinenum;
+  std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression();
+
+  int level = 1;
+  while (m_pToken->m_type == TOKassign) {
+    NextToken();
+    std::unique_ptr<CXFA_FMSimpleExpression> pExp2 = ParseLogicalOrExpression();
+    if (level++ == kMaxAssignmentChainLength)
+      Error(kFMErrLongAssignmentChain);
+    if (m_pErrorInfo->message.IsEmpty()) {
+      pExp1 = pdfium::MakeUnique<CXFA_FMAssignExpression>(
+          line, TOKassign, std::move(pExp1), std::move(pExp2));
+    } else {
+      pExp1.reset();
+    }
+  }
+  Check(TOKrparen);
+  return pExp1;
+}
+
+std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseBlockExpression() {
+  uint32_t line = m_pToken->m_uLinenum;
+  std::unique_ptr<CXFA_FMExpression> expr;
+  std::vector<std::unique_ptr<CXFA_FMExpression>> expressions;
+
+  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:
+        expr = ParseFunction();
+        if (expr) {
+          expressions.push_back(std::move(expr));
+        }
+        continue;
+      default:
+        expr = ParseExpression();
+        if (expr) {
+          expressions.push_back(std::move(expr));
+        }
+        continue;
+    }
+    break;
+  }
+  std::unique_ptr<CXFA_FMBlockExpression> pExp;
+  if (m_pErrorInfo->message.IsEmpty()) {
+    pExp = pdfium::MakeUnique<CXFA_FMBlockExpression>(line,
+                                                      std::move(expressions));
+  }
+  return pExp;
+}
+
+std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseIfExpression() {
+  uint32_t line = m_pToken->m_uLinenum;
+  const wchar_t* pStartPos = m_lexer->GetPos();
+  NextToken();
+  Check(TOKlparen);
+  std::unique_ptr<CXFA_FMSimpleExpression> pExpression;
+  while (m_pToken->m_type != TOKrparen) {
+    pExpression = ParseSimpleExpression();
+    if (m_pToken->m_type != TOKcomma)
+      break;
+    NextToken();
+  }
+  Check(TOKrparen);
+  if (m_pToken->m_type != TOKthen) {
+    m_lexer->SetCurrentLine(line);
+    auto pNewToken = pdfium::MakeUnique<CXFA_FMToken>(line);
+    m_pToken = pNewToken.get();
+    m_pToken->m_type = TOKidentifier;
+    m_pToken->m_wstring = L"if";
+    m_lexer->SetToken(std::move(pNewToken));
+    m_lexer->SetPos(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 = ParseIfExpression();
+      Check(TOKendif);
+      break;
+    case TOKelseif:
+      pElseExpression = ParseIfExpression();
+      break;
+    case TOKelse:
+      NextToken();
+      pElseExpression = ParseBlockExpression();
+      Check(TOKendif);
+      break;
+    default:
+      Error(kFMErrExpectedEndIf, m_pToken->m_wstring.c_str());
+      NextToken();
+      break;
+  }
+  std::unique_ptr<CXFA_FMIfExpression> pExp;
+  if (m_pErrorInfo->message.IsEmpty()) {
+    pExp = pdfium::MakeUnique<CXFA_FMIfExpression>(line, std::move(pExpression),
+                                                   std::move(pIfExpression),
+                                                   std::move(pElseExpression));
+  }
+  return pExp;
+}
+
+std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseWhileExpression() {
+  uint32_t 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> expr;
+  if (m_pErrorInfo->message.IsEmpty()) {
+    expr = pdfium::MakeUnique<CXFA_FMWhileExpression>(
+        line, std::move(pCondition), std::move(pExpression));
+  }
+  return expr;
+}
+
+std::unique_ptr<CXFA_FMSimpleExpression>
+CXFA_FMParse::ParseSubassignmentInForExpression() {
+  std::unique_ptr<CXFA_FMSimpleExpression> expr;
+  switch (m_pToken->m_type) {
+    case TOKidentifier:
+      expr = ParseSimpleExpression();
+      break;
+    default:
+      Error(kFMErrUnexpectedExpression, m_pToken->m_wstring.c_str());
+      NextToken();
+      break;
+  }
+  return expr;
+}
+
+std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseForExpression() {
+  CFX_WideStringC wsVariant;
+  uint32_t line = m_pToken->m_uLinenum;
+  NextToken();
+  if (m_pToken->m_type != TOKidentifier) {
+    Error(kFMErrExpectedToken, XFA_FM_KeywordToString(m_pToken->m_type),
+          m_pToken->m_wstring.c_str());
+  }
+  wsVariant = m_pToken->m_wstring;
+  NextToken();
+  std::unique_ptr<CXFA_FMSimpleExpression> pAssignment;
+  if (m_pToken->m_type == TOKassign) {
+    NextToken();
+    pAssignment = ParseSimpleExpression();
+  } else {
+    Error(kFMErrExpectedToken, XFA_FM_KeywordToString(m_pToken->m_type),
+          m_pToken->m_wstring.c_str());
+  }
+  int32_t iDirection = 0;
+  if (m_pToken->m_type == TOKupto) {
+    iDirection = 1;
+  } else if (m_pToken->m_type == TOKdownto) {
+    iDirection = -1;
+  } else {
+    Error(kFMErrExpectedToken, L"upto or downto", m_pToken->m_wstring.c_str());
+  }
+  NextToken();
+  std::unique_ptr<CXFA_FMSimpleExpression> pAccessor = ParseSimpleExpression();
+  std::unique_ptr<CXFA_FMSimpleExpression> pStep;
+  if (m_pToken->m_type == TOKstep) {
+    NextToken();
+    pStep = ParseSimpleExpression();
+  }
+  Check(TOKdo);
+  std::unique_ptr<CXFA_FMExpression> pList = ParseBlockExpression();
+  Check(TOKendfor);
+  std::unique_ptr<CXFA_FMExpression> expr;
+  if (m_pErrorInfo->message.IsEmpty()) {
+    expr = pdfium::MakeUnique<CXFA_FMForExpression>(
+        line, wsVariant, std::move(pAssignment), std::move(pAccessor),
+        iDirection, std::move(pStep), std::move(pList));
+  }
+  return expr;
+}
+
+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;
+  uint32_t line = m_pToken->m_uLinenum;
+  NextToken();
+  if (m_pToken->m_type != TOKidentifier) {
+    Error(kFMErrExpectedToken, XFA_FM_KeywordToString(m_pToken->m_type),
+          m_pToken->m_wstring.c_str());
+  }
+  wsIdentifier = m_pToken->m_wstring;
+  NextToken();
+  Check(TOKin);
+  Check(TOKlparen);
+  if (m_pToken->m_type == TOKrparen) {
+    Error(kFMErrUnexpectedExpression, m_pToken->m_wstring.c_str());
+    NextToken();
+  } else {
+    while (m_pToken->m_type != TOKrparen) {
+      std::unique_ptr<CXFA_FMSimpleExpression> s = ParseSimpleExpression();
+      if (s)
+        pAccessors.push_back(std::move(s));
+      if (m_pToken->m_type != TOKcomma)
+        break;
+      NextToken();
+    }
+    Check(TOKrparen);
+  }
+  Check(TOKdo);
+  pList = ParseBlockExpression();
+  Check(TOKendfor);
+  if (m_pErrorInfo->message.IsEmpty()) {
+    expr = pdfium::MakeUnique<CXFA_FMForeachExpression>(
+        line, wsIdentifier, std::move(pAccessors), std::move(pList));
+  }
+  return expr;
+}
+
+std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseDoExpression() {
+  uint32_t line = m_pToken->m_uLinenum;
+  NextToken();
+  std::unique_ptr<CXFA_FMExpression> expr = ParseBlockExpression();
+  Check(TOKend);
+  if (HasError())
+    return nullptr;
+
+  return pdfium::MakeUnique<CXFA_FMDoExpression>(line, std::move(expr));
+}
+
+bool CXFA_FMParse::HasError() const {
+  return !m_pErrorInfo->message.IsEmpty();
+}