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, 0 insertions, 998 deletions

diff --git a/xfa/fxfa/fm2js/xfa_fmparse.cpp b/xfa/fxfa/fm2js/xfa_fmparse.cpp
deleted file mode 100644
index 4f6f6bac58..0000000000
--- a/xfa/fxfa/fm2js/xfa_fmparse.cpp
+++ /dev/null
@@ -1,998 +0,0 @@
-// 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>
-#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();
-}