summaryrefslogtreecommitdiff
path: root/xfa
diff options
context:
space:
mode:
Diffstat (limited to 'xfa')
-rw-r--r--xfa/fxfa/fm2js/cxfa_fmlexer.cpp192
-rw-r--r--xfa/fxfa/fm2js/cxfa_fmlexer.h19
-rw-r--r--xfa/fxfa/fm2js/cxfa_fmlexer_unittest.cpp135
-rw-r--r--xfa/fxfa/fm2js/cxfa_fmparser.cpp222
-rw-r--r--xfa/fxfa/fm2js/cxfa_fmparser.h2
5 files changed, 272 insertions, 298 deletions
diff --git a/xfa/fxfa/fm2js/cxfa_fmlexer.cpp b/xfa/fxfa/fm2js/cxfa_fmlexer.cpp
index 5ae1225541..78e99a53e3 100644
--- a/xfa/fxfa/fm2js/cxfa_fmlexer.cpp
+++ b/xfa/fxfa/fm2js/cxfa_fmlexer.cpp
@@ -110,12 +110,13 @@ XFA_FM_TOKEN TokenizeIdentifier(const WideStringView& str) {
} // namespace
-CXFA_FMToken::CXFA_FMToken() : m_type(TOKreserver), m_line_num(1) {}
+CXFA_FMToken::CXFA_FMToken(XFA_FM_TOKEN token) : m_type(token) {}
-CXFA_FMToken::CXFA_FMToken(uint32_t line_num)
- : m_type(TOKreserver), m_line_num(line_num) {}
+CXFA_FMToken::CXFA_FMToken() : CXFA_FMToken(TOKreserver) {}
-CXFA_FMToken::~CXFA_FMToken() {}
+CXFA_FMToken::CXFA_FMToken(const CXFA_FMToken&) = default;
+
+CXFA_FMToken::~CXFA_FMToken() = default;
#ifndef NDEBUG
WideString CXFA_FMToken::ToDebugString() const {
@@ -123,8 +124,6 @@ WideString CXFA_FMToken::ToDebugString() const {
str += tokenStrings[m_type];
str += L", string = ";
str += m_string;
- str += L", line_num = ";
- str += std::to_wstring(m_line_num).c_str();
return str;
}
#endif // NDEBUG
@@ -137,21 +136,19 @@ CXFA_FMLexer::CXFA_FMLexer(const WideStringView& wsFormCalc)
CXFA_FMLexer::~CXFA_FMLexer() {}
-std::unique_ptr<CXFA_FMToken> CXFA_FMLexer::NextToken() {
+CXFA_FMToken CXFA_FMLexer::NextToken() {
if (m_lexer_error)
- return nullptr;
+ return CXFA_FMToken();
- m_token = pdfium::MakeUnique<CXFA_FMToken>(m_current_line);
while (m_cursor <= m_end && *m_cursor) {
if (!IsFormCalcCharacter(*m_cursor)) {
RaiseError();
- return nullptr;
+ return CXFA_FMToken();
}
switch (*m_cursor) {
case '\n':
++m_current_line;
- m_token->m_line_num = m_current_line;
++m_cursor;
break;
case '\r':
@@ -161,9 +158,7 @@ std::unique_ptr<CXFA_FMToken> CXFA_FMLexer::NextToken() {
AdvanceForComment();
break;
case '"':
- m_token->m_type = TOKstring;
- AdvanceForString();
- return std::move(m_token);
+ return AdvanceForString();
case '0':
case '1':
case '2':
@@ -174,153 +169,125 @@ std::unique_ptr<CXFA_FMToken> CXFA_FMLexer::NextToken() {
case '7':
case '8':
case '9':
- m_token->m_type = TOKnumber;
- AdvanceForNumber();
- return std::move(m_token);
+ return AdvanceForNumber();
case '=':
++m_cursor;
- if (m_cursor > m_end) {
- m_token->m_type = TOKassign;
- return std::move(m_token);
- }
+ if (m_cursor > m_end)
+ return CXFA_FMToken(TOKassign);
if (!IsFormCalcCharacter(*m_cursor)) {
RaiseError();
- return nullptr;
+ return CXFA_FMToken();
}
if (*m_cursor == '=') {
- m_token->m_type = TOKeq;
++m_cursor;
- } else {
- m_token->m_type = TOKassign;
+ return CXFA_FMToken(TOKeq);
}
- return std::move(m_token);
+ return CXFA_FMToken(TOKassign);
case '<':
++m_cursor;
- if (m_cursor > m_end) {
- m_token->m_type = TOKlt;
- return std::move(m_token);
- }
+ if (m_cursor > m_end)
+ return CXFA_FMToken(TOKlt);
if (!IsFormCalcCharacter(*m_cursor)) {
RaiseError();
- return nullptr;
+ return CXFA_FMToken();
}
if (*m_cursor == '=') {
- m_token->m_type = TOKle;
++m_cursor;
- } else if (*m_cursor == '>') {
- m_token->m_type = TOKne;
+ return CXFA_FMToken(TOKle);
+ }
+ if (*m_cursor == '>') {
++m_cursor;
- } else {
- m_token->m_type = TOKlt;
+ return CXFA_FMToken(TOKne);
}
- return std::move(m_token);
+ return CXFA_FMToken(TOKlt);
case '>':
++m_cursor;
- if (m_cursor > m_end) {
- m_token->m_type = TOKgt;
- return std::move(m_token);
- }
+ if (m_cursor > m_end)
+ return CXFA_FMToken(TOKgt);
if (!IsFormCalcCharacter(*m_cursor)) {
RaiseError();
- return nullptr;
+ return CXFA_FMToken();
}
if (*m_cursor == '=') {
- m_token->m_type = TOKge;
++m_cursor;
- } else {
- m_token->m_type = TOKgt;
+ return CXFA_FMToken(TOKge);
}
- return std::move(m_token);
+ return CXFA_FMToken(TOKgt);
case ',':
- m_token->m_type = TOKcomma;
++m_cursor;
- return std::move(m_token);
+ return CXFA_FMToken(TOKcomma);
case '(':
- m_token->m_type = TOKlparen;
++m_cursor;
- return std::move(m_token);
+ return CXFA_FMToken(TOKlparen);
case ')':
- m_token->m_type = TOKrparen;
++m_cursor;
- return std::move(m_token);
+ return CXFA_FMToken(TOKrparen);
case '[':
- m_token->m_type = TOKlbracket;
++m_cursor;
- return std::move(m_token);
+ return CXFA_FMToken(TOKlbracket);
case ']':
- m_token->m_type = TOKrbracket;
++m_cursor;
- return std::move(m_token);
+ return CXFA_FMToken(TOKrbracket);
case '&':
++m_cursor;
- m_token->m_type = TOKand;
- return std::move(m_token);
+ return CXFA_FMToken(TOKand);
case '|':
++m_cursor;
- m_token->m_type = TOKor;
- return std::move(m_token);
+ return CXFA_FMToken(TOKor);
case '+':
++m_cursor;
- m_token->m_type = TOKplus;
- return std::move(m_token);
+ return CXFA_FMToken(TOKplus);
case '-':
++m_cursor;
- m_token->m_type = TOKminus;
- return std::move(m_token);
+ return CXFA_FMToken(TOKminus);
case '*':
++m_cursor;
- m_token->m_type = TOKmul;
- return std::move(m_token);
+ return CXFA_FMToken(TOKmul);
case '/': {
++m_cursor;
- if (m_cursor > m_end) {
- m_token->m_type = TOKdiv;
- return std::move(m_token);
- }
+ if (m_cursor > m_end)
+ return CXFA_FMToken(TOKdiv);
if (!IsFormCalcCharacter(*m_cursor)) {
RaiseError();
- return nullptr;
- }
- if (*m_cursor != '/') {
- m_token->m_type = TOKdiv;
- return std::move(m_token);
+ return CXFA_FMToken();
}
+ if (*m_cursor != '/')
+ return CXFA_FMToken(TOKdiv);
+
AdvanceForComment();
break;
}
case '.':
++m_cursor;
- if (m_cursor > m_end) {
- m_token->m_type = TOKdot;
- return std::move(m_token);
- }
+ if (m_cursor > m_end)
+ return CXFA_FMToken(TOKdot);
if (!IsFormCalcCharacter(*m_cursor)) {
RaiseError();
- return nullptr;
+ return CXFA_FMToken();
}
if (*m_cursor == '.') {
- m_token->m_type = TOKdotdot;
++m_cursor;
- } else if (*m_cursor == '*') {
- m_token->m_type = TOKdotstar;
+ return CXFA_FMToken(TOKdotdot);
+ }
+ if (*m_cursor == '*') {
++m_cursor;
- } else if (*m_cursor == '#') {
- m_token->m_type = TOKdotscream;
+ return CXFA_FMToken(TOKdotstar);
+ }
+ if (*m_cursor == '#') {
++m_cursor;
- } else if (*m_cursor <= '9' && *m_cursor >= '0') {
- m_token->m_type = TOKnumber;
+ return CXFA_FMToken(TOKdotscream);
+ }
+ if (*m_cursor <= '9' && *m_cursor >= '0') {
--m_cursor;
- AdvanceForNumber();
- } else {
- m_token->m_type = TOKdot;
+ return AdvanceForNumber();
}
- return std::move(m_token);
+ return CXFA_FMToken(TOKdot);
default:
if (IsWhitespaceCharacter(*m_cursor)) {
++m_cursor;
@@ -328,35 +295,34 @@ std::unique_ptr<CXFA_FMToken> CXFA_FMLexer::NextToken() {
}
if (!IsInitialIdentifierCharacter(*m_cursor)) {
RaiseError();
- return nullptr;
+ return CXFA_FMToken();
}
- AdvanceForIdentifier();
- return std::move(m_token);
+ return AdvanceForIdentifier();
}
}
-
- // If there isn't currently a token type then mark it EOF.
- if (m_token->m_type == TOKreserver)
- m_token->m_type = TOKeof;
- return std::move(m_token);
+ return CXFA_FMToken(TOKeof);
}
-void CXFA_FMLexer::AdvanceForNumber() {
+CXFA_FMToken CXFA_FMLexer::AdvanceForNumber() {
// This will set end to the character after the end of the number.
wchar_t* end = nullptr;
if (m_cursor)
wcstod(const_cast<wchar_t*>(m_cursor), &end);
if (!end || FXSYS_iswalpha(*end)) {
RaiseError();
- return;
+ return CXFA_FMToken();
}
- m_token->m_string =
+ CXFA_FMToken token(TOKnumber);
+ token.m_string =
WideStringView(m_cursor, static_cast<size_t>(end - m_cursor));
m_cursor = end;
+ return token;
}
-void CXFA_FMLexer::AdvanceForString() {
+CXFA_FMToken CXFA_FMLexer::AdvanceForString() {
+ CXFA_FMToken token(TOKstring);
+
const wchar_t* start = m_cursor;
++m_cursor;
while (m_cursor <= m_end && *m_cursor) {
@@ -368,9 +334,9 @@ void CXFA_FMLexer::AdvanceForString() {
++m_cursor;
// If the end of the input has been reached it was not escaped.
if (m_cursor > m_end) {
- m_token->m_string =
+ token.m_string =
WideStringView(start, static_cast<size_t>(m_cursor - start));
- return;
+ return token;
}
// If the next character is not a " then the end of the string has been
// found.
@@ -378,8 +344,8 @@ void CXFA_FMLexer::AdvanceForString() {
if (!IsFormCalcCharacter(*m_cursor))
break;
- m_token->m_string = WideStringView(start, (m_cursor - start));
- return;
+ token.m_string = WideStringView(start, (m_cursor - start));
+ return token;
}
}
++m_cursor;
@@ -387,24 +353,28 @@ void CXFA_FMLexer::AdvanceForString() {
// Didn't find the end of the string.
RaiseError();
+ return CXFA_FMToken();
}
-void CXFA_FMLexer::AdvanceForIdentifier() {
+CXFA_FMToken CXFA_FMLexer::AdvanceForIdentifier() {
const wchar_t* start = m_cursor;
++m_cursor;
while (m_cursor <= m_end && *m_cursor) {
if (!IsFormCalcCharacter(*m_cursor)) {
RaiseError();
- return;
+ return CXFA_FMToken();
}
if (!IsIdentifierCharacter(*m_cursor))
break;
++m_cursor;
}
- m_token->m_string =
+
+ WideStringView str =
WideStringView(start, static_cast<size_t>(m_cursor - start));
- m_token->m_type = TokenizeIdentifier(m_token->m_string);
+ CXFA_FMToken token(TokenizeIdentifier(str));
+ token.m_string = str;
+ return token;
}
void CXFA_FMLexer::AdvanceForComment() {
diff --git a/xfa/fxfa/fm2js/cxfa_fmlexer.h b/xfa/fxfa/fm2js/cxfa_fmlexer.h
index c94f2a901f..eb9e45e180 100644
--- a/xfa/fxfa/fm2js/cxfa_fmlexer.h
+++ b/xfa/fxfa/fm2js/cxfa_fmlexer.h
@@ -91,7 +91,8 @@ struct XFA_FMKeyword {
class CXFA_FMToken {
public:
CXFA_FMToken();
- explicit CXFA_FMToken(uint32_t line_num);
+ explicit CXFA_FMToken(XFA_FM_TOKEN token);
+ CXFA_FMToken(const CXFA_FMToken&);
~CXFA_FMToken();
#ifndef NDEBUG
@@ -100,7 +101,6 @@ class CXFA_FMToken {
WideStringView m_string;
XFA_FM_TOKEN m_type;
- uint32_t m_line_num;
};
class CXFA_FMLexer {
@@ -108,27 +108,24 @@ class CXFA_FMLexer {
explicit CXFA_FMLexer(const WideStringView& wsFormcalc);
~CXFA_FMLexer();
- std::unique_ptr<CXFA_FMToken> NextToken();
+ CXFA_FMToken NextToken();
+ uint32_t GetCurrentLine() const { return m_current_line; }
void SetCurrentLine(uint32_t line) { m_current_line = line; }
const wchar_t* GetPos() { return m_cursor; }
void SetPos(const wchar_t* pos) { m_cursor = pos; }
private:
- void AdvanceForNumber();
- void AdvanceForString();
- void AdvanceForIdentifier();
+ CXFA_FMToken AdvanceForNumber();
+ CXFA_FMToken AdvanceForString();
+ CXFA_FMToken AdvanceForIdentifier();
void AdvanceForComment();
- void RaiseError() {
- m_token.reset();
- m_lexer_error = true;
- }
+ void RaiseError() { m_lexer_error = true; }
const wchar_t* m_cursor;
const wchar_t* const m_end;
uint32_t m_current_line;
- std::unique_ptr<CXFA_FMToken> m_token;
bool m_lexer_error;
};
diff --git a/xfa/fxfa/fm2js/cxfa_fmlexer_unittest.cpp b/xfa/fxfa/fm2js/cxfa_fmlexer_unittest.cpp
index a6ab871b18..00dc494582 100644
--- a/xfa/fxfa/fm2js/cxfa_fmlexer_unittest.cpp
+++ b/xfa/fxfa/fm2js/cxfa_fmlexer_unittest.cpp
@@ -12,86 +12,86 @@
TEST(CXFA_FMLexerTest, EmptyString) {
CXFA_FMLexer lexer(L"");
- std::unique_ptr<CXFA_FMToken> token = lexer.NextToken();
- EXPECT_EQ(TOKeof, token->m_type);
+ CXFA_FMToken token = lexer.NextToken();
+ EXPECT_EQ(TOKeof, token.m_type);
}
TEST(CXFA_FMLexerTest, Numbers) {
auto lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"-12");
- std::unique_ptr<CXFA_FMToken> token = lexer->NextToken();
+ CXFA_FMToken token = lexer->NextToken();
// TODO(dsinclair): Should this return -12 instead of two tokens?
- EXPECT_EQ(TOKminus, token->m_type);
+ EXPECT_EQ(TOKminus, token.m_type);
token = lexer->NextToken();
- EXPECT_EQ(L"12", token->m_string);
+ EXPECT_EQ(L"12", token.m_string);
token = lexer->NextToken();
- EXPECT_EQ(TOKeof, token->m_type);
+ EXPECT_EQ(TOKeof, token.m_type);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"1.5362");
token = lexer->NextToken();
- EXPECT_EQ(TOKnumber, token->m_type);
- EXPECT_EQ(L"1.5362", token->m_string);
+ EXPECT_EQ(TOKnumber, token.m_type);
+ EXPECT_EQ(L"1.5362", token.m_string);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"0.875");
token = lexer->NextToken();
- EXPECT_EQ(TOKnumber, token->m_type);
- EXPECT_EQ(L"0.875", token->m_string);
+ EXPECT_EQ(TOKnumber, token.m_type);
+ EXPECT_EQ(L"0.875", token.m_string);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"5.56e-2");
token = lexer->NextToken();
- EXPECT_EQ(TOKnumber, token->m_type);
- EXPECT_EQ(L"5.56e-2", token->m_string);
+ EXPECT_EQ(TOKnumber, token.m_type);
+ EXPECT_EQ(L"5.56e-2", token.m_string);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"1.234E10");
token = lexer->NextToken();
- EXPECT_EQ(TOKnumber, token->m_type);
- EXPECT_EQ(L"1.234E10", token->m_string);
+ EXPECT_EQ(TOKnumber, token.m_type);
+ EXPECT_EQ(L"1.234E10", token.m_string);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"123456789.012345678");
token = lexer->NextToken();
- EXPECT_EQ(TOKnumber, token->m_type);
+ EXPECT_EQ(TOKnumber, token.m_type);
// TODO(dsinclair): This should round as per IEEE 64-bit values.
- // EXPECT_EQ(L"123456789.01234567", token->m_string);
- EXPECT_EQ(L"123456789.012345678", token->m_string);
+ // EXPECT_EQ(L"123456789.01234567", token.m_string);
+ EXPECT_EQ(L"123456789.012345678", token.m_string);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"99999999999999999");
token = lexer->NextToken();
- EXPECT_EQ(TOKnumber, token->m_type);
+ EXPECT_EQ(TOKnumber, token.m_type);
// TODO(dsinclair): This is spec'd as rounding when > 16 significant digits
// prior to the exponent.
- // EXPECT_EQ(L"100000000000000000", token->m_string);
- EXPECT_EQ(L"99999999999999999", token->m_string);
+ // EXPECT_EQ(L"100000000000000000", token.m_string);
+ EXPECT_EQ(L"99999999999999999", token.m_string);
}
// The quotes are stripped in CXFA_FMStringExpression::ToJavaScript.
TEST(CXFA_FMLexerTest, Strings) {
auto lexer =
pdfium::MakeUnique<CXFA_FMLexer>(L"\"The cat jumped over the fence.\"");
- std::unique_ptr<CXFA_FMToken> token = lexer->NextToken();
- EXPECT_EQ(TOKstring, token->m_type);
- EXPECT_EQ(L"\"The cat jumped over the fence.\"", token->m_string);
+ CXFA_FMToken token = lexer->NextToken();
+ EXPECT_EQ(TOKstring, token.m_type);
+ EXPECT_EQ(L"\"The cat jumped over the fence.\"", token.m_string);
token = lexer->NextToken();
- EXPECT_EQ(TOKeof, token->m_type);
+ EXPECT_EQ(TOKeof, token.m_type);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"\"\"");
token = lexer->NextToken();
- EXPECT_EQ(TOKstring, token->m_type);
- EXPECT_EQ(L"\"\"", token->m_string);
+ EXPECT_EQ(TOKstring, token.m_type);
+ EXPECT_EQ(L"\"\"", token.m_string);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(
L"\"The message reads: \"\"Warning: Insufficient Memory\"\"\"");
token = lexer->NextToken();
- EXPECT_EQ(TOKstring, token->m_type);
+ EXPECT_EQ(TOKstring, token.m_type);
EXPECT_EQ(L"\"The message reads: \"\"Warning: Insufficient Memory\"\"\"",
- token->m_string);
+ token.m_string);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(
L"\"\\u0047\\u006f\\u0066\\u0069\\u0073\\u0068\\u0021\\u000d\\u000a\"");
token = lexer->NextToken();
- EXPECT_EQ(TOKstring, token->m_type);
+ EXPECT_EQ(TOKstring, token.m_type);
EXPECT_EQ(
L"\"\\u0047\\u006f\\u0066\\u0069\\u0073\\u0068\\u0021\\u000d\\u000a\"",
- token->m_string);
+ token.m_string);
}
// Note, 'this' is a keyword but is not matched by the lexer.
@@ -161,51 +161,51 @@ TEST(CXFA_FMLexerTest, OperatorsAndKeywords) {
for (size_t i = 0; i < FX_ArraySize(op); ++i) {
auto lexer = pdfium::MakeUnique<CXFA_FMLexer>(op[i].op);
- std::unique_ptr<CXFA_FMToken> token = lexer->NextToken();
- EXPECT_EQ(op[i].token, token->m_type);
+ CXFA_FMToken token = lexer->NextToken();
+ EXPECT_EQ(op[i].token, token.m_type);
}
}
TEST(CXFA_FMLexerTest, Comments) {
auto lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"// Empty.");
- std::unique_ptr<CXFA_FMToken> token = lexer->NextToken();
- EXPECT_EQ(TOKeof, token->m_type);
+ CXFA_FMToken token = lexer->NextToken();
+ EXPECT_EQ(TOKeof, token.m_type);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"//");
token = lexer->NextToken();
- EXPECT_EQ(TOKeof, token->m_type);
+ EXPECT_EQ(TOKeof, token.m_type);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"123 // Empty.\n\"str\"");
token = lexer->NextToken();
- EXPECT_EQ(TOKnumber, token->m_type);
- EXPECT_EQ(L"123", token->m_string);
+ EXPECT_EQ(TOKnumber, token.m_type);
+ EXPECT_EQ(L"123", token.m_string);
token = lexer->NextToken();
- EXPECT_EQ(TOKstring, token->m_type);
- EXPECT_EQ(L"\"str\"", token->m_string);
+ EXPECT_EQ(TOKstring, token.m_type);
+ EXPECT_EQ(L"\"str\"", token.m_string);
token = lexer->NextToken();
- EXPECT_EQ(TOKeof, token->m_type);
+ EXPECT_EQ(TOKeof, token.m_type);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L";");
token = lexer->NextToken();
- EXPECT_EQ(TOKeof, token->m_type);
+ EXPECT_EQ(TOKeof, token.m_type);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"; Empty.");
token = lexer->NextToken();
- EXPECT_EQ(TOKeof, token->m_type);
+ EXPECT_EQ(TOKeof, token.m_type);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"123 ;Empty.\n\"str\"");
token = lexer->NextToken();
- EXPECT_EQ(TOKnumber, token->m_type);
- EXPECT_EQ(L"123", token->m_string);
+ EXPECT_EQ(TOKnumber, token.m_type);
+ EXPECT_EQ(L"123", token.m_string);
token = lexer->NextToken();
- EXPECT_EQ(TOKstring, token->m_type);
- EXPECT_EQ(L"\"str\"", token->m_string);
+ EXPECT_EQ(TOKstring, token.m_type);
+ EXPECT_EQ(L"\"str\"", token.m_string);
token = lexer->NextToken();
- EXPECT_EQ(TOKeof, token->m_type);
+ EXPECT_EQ(TOKeof, token.m_type);
}
TEST(CXFA_FMLexerTest, ValidIdentifiers) {
@@ -213,43 +213,50 @@ TEST(CXFA_FMLexerTest, ValidIdentifiers) {
L"a", L"an_identifier", L"_ident", L"$ident", L"!ident", L"GetAddr"};
for (const auto* ident : identifiers) {
auto lexer = pdfium::MakeUnique<CXFA_FMLexer>(ident);
- std::unique_ptr<CXFA_FMToken> token = lexer->NextToken();
- EXPECT_EQ(TOKidentifier, token->m_type);
- EXPECT_EQ(ident, token->m_string);
+ CXFA_FMToken token = lexer->NextToken();
+ EXPECT_EQ(TOKidentifier, token.m_type);
+ EXPECT_EQ(ident, token.m_string);
}
}
TEST(CXFA_FMLexerTest, InvalidIdentifiers) {
auto lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"#a");
- EXPECT_EQ(nullptr, lexer->NextToken());
+ auto token = lexer->NextToken();
+ EXPECT_EQ(TOKreserver, token.m_type);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"1a");
- EXPECT_EQ(nullptr, lexer->NextToken());
+ token = lexer->NextToken();
+ EXPECT_EQ(TOKreserver, token.m_type);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"an@identifier");
- EXPECT_NE(nullptr, lexer->NextToken());
- EXPECT_EQ(nullptr, lexer->NextToken());
- EXPECT_EQ(nullptr, lexer->NextToken());
+ token = lexer->NextToken();
+ EXPECT_NE(TOKreserver, token.m_type);
+ token = lexer->NextToken();
+ EXPECT_EQ(TOKreserver, token.m_type);
+ token = lexer->NextToken();
+ EXPECT_EQ(TOKreserver, token.m_type);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"_ident@");
- EXPECT_NE(nullptr, lexer->NextToken());
- EXPECT_EQ(nullptr, lexer->NextToken());
+ token = lexer->NextToken();
+ EXPECT_NE(TOKreserver, token.m_type);
+ token = lexer->NextToken();
+ EXPECT_EQ(TOKreserver, token.m_type);
}
TEST(CXFA_FMLexerTest, Whitespace) {
auto lexer = pdfium::MakeUnique<CXFA_FMLexer>(L" \t\xc\x9\xb");
- std::unique_ptr<CXFA_FMToken> token = lexer->NextToken();
- EXPECT_EQ(TOKeof, token->m_type);
+ CXFA_FMToken token = lexer->NextToken();
+ EXPECT_EQ(TOKeof, token.m_type);
lexer = pdfium::MakeUnique<CXFA_FMLexer>(L"123 \t\xc\x9\xb 456");
token = lexer->NextToken();
- EXPECT_EQ(TOKnumber, token->m_type);
- EXPECT_EQ(L"123", token->m_string);
+ EXPECT_EQ(TOKnumber, token.m_type);
+ EXPECT_EQ(L"123", token.m_string);
token = lexer->NextToken();
- EXPECT_EQ(TOKnumber, token->m_type);
- EXPECT_EQ(L"456", token->m_string);
+ EXPECT_EQ(TOKnumber, token.m_type);
+ EXPECT_EQ(L"456", token.m_string);
token = lexer->NextToken();
- EXPECT_EQ(TOKeof, token->m_type);
+ EXPECT_EQ(TOKeof, token.m_type);
}
diff --git a/xfa/fxfa/fm2js/cxfa_fmparser.cpp b/xfa/fxfa/fm2js/cxfa_fmparser.cpp
index e634f97013..948d9eb2f6 100644
--- a/xfa/fxfa/fm2js/cxfa_fmparser.cpp
+++ b/xfa/fxfa/fm2js/cxfa_fmparser.cpp
@@ -42,8 +42,9 @@ std::unique_ptr<CXFA_FMFunctionDefinition> CXFA_FMParser::Parse() {
bool CXFA_FMParser::NextToken() {
if (HasError())
return false;
+
m_token = m_lexer->NextToken();
- while (!HasError() && m_token->m_type == TOKreserver)
+ while (!HasError() && m_token.m_type == TOKreserver)
m_token = m_lexer->NextToken();
return !HasError();
}
@@ -52,7 +53,7 @@ bool CXFA_FMParser::CheckThenNext(XFA_FM_TOKEN op) {
if (HasError())
return false;
- if (m_token->m_type != op) {
+ if (m_token.m_type != op) {
m_error = true;
return false;
}
@@ -72,13 +73,13 @@ CXFA_FMParser::ParseTopExpression() {
std::unique_ptr<CXFA_FMExpression> expr;
std::vector<std::unique_ptr<CXFA_FMExpression>> expressions;
while (!HasError()) {
- if (m_token->m_type == TOKeof || m_token->m_type == TOKendfunc ||
- m_token->m_type == TOKendif || m_token->m_type == TOKelseif ||
- m_token->m_type == TOKelse || m_token->m_type == TOKreserver) {
+ if (m_token.m_type == TOKeof || m_token.m_type == TOKendfunc ||
+ m_token.m_type == TOKendif || m_token.m_type == TOKelseif ||
+ m_token.m_type == TOKelse || m_token.m_type == TOKreserver) {
return expressions;
}
- expr = m_token->m_type == TOKfunc ? ParseFunction() : ParseExpression();
+ expr = m_token.m_type == TOKfunc ? ParseFunction() : ParseExpression();
if (!expr) {
m_error = true;
break;
@@ -96,37 +97,37 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseFunction() {
WideStringView ident;
std::vector<WideStringView> arguments;
std::vector<std::unique_ptr<CXFA_FMExpression>> expressions;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
if (!NextToken())
return nullptr;
- if (m_token->m_type != TOKidentifier) {
+ if (m_token.m_type != TOKidentifier) {
m_error = true;
return nullptr;
} else {
- ident = m_token->m_string;
+ ident = m_token.m_string;
if (!NextToken())
return nullptr;
}
if (!CheckThenNext(TOKlparen))
return nullptr;
- if (m_token->m_type == TOKrparen) {
+ if (m_token.m_type == TOKrparen) {
if (!NextToken())
return nullptr;
} else {
while (1) {
- if (m_token->m_type != TOKidentifier) {
+ if (m_token.m_type != TOKidentifier) {
m_error = true;
return nullptr;
}
- arguments.push_back(m_token->m_string);
+ arguments.push_back(m_token.m_string);
if (!NextToken())
return nullptr;
- if (m_token->m_type == TOKcomma) {
+ if (m_token.m_type == TOKcomma) {
if (!NextToken())
return nullptr;
continue;
}
- if (m_token->m_type == TOKrparen) {
+ if (m_token.m_type == TOKrparen) {
if (!NextToken())
return nullptr;
} else {
@@ -138,7 +139,7 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseFunction() {
}
if (!CheckThenNext(TOKdo))
return nullptr;
- if (m_token->m_type == TOKendfunc) {
+ if (m_token.m_type == TOKendfunc) {
if (!NextToken())
return nullptr;
} else {
@@ -157,8 +158,8 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseExpression() {
return nullptr;
std::unique_ptr<CXFA_FMExpression> expr;
- uint32_t line = m_token->m_line_num;
- switch (m_token->m_type) {
+ uint32_t line = m_lexer->GetCurrentLine();
+ switch (m_token.m_type) {
case TOKvar:
expr = ParseVarExpression();
break;
@@ -210,20 +211,20 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseVarExpression() {
return nullptr;
WideStringView ident;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
if (!NextToken())
return nullptr;
- if (m_token->m_type != TOKidentifier) {
+ if (m_token.m_type != TOKidentifier) {
m_error = true;
return nullptr;
}
- ident = m_token->m_string;
+ ident = m_token.m_string;
if (!NextToken())
return nullptr;
std::unique_ptr<CXFA_FMExpression> expr;
- if (m_token->m_type == TOKassign) {
+ if (m_token.m_type == TOKassign) {
if (!NextToken())
return nullptr;
@@ -240,12 +241,12 @@ CXFA_FMParser::ParseSimpleExpression() {
if (HasError())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression();
if (!pExp1)
return nullptr;
int level = 1;
- while (m_token->m_type == TOKassign) {
+ while (m_token.m_type == TOKassign) {
if (!NextToken())
return nullptr;
std::unique_ptr<CXFA_FMSimpleExpression> pExp2 = ParseLogicalOrExpression();
@@ -266,7 +267,7 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseExpExpression() {
if (HasError() || !IncrementParseDepthAndCheck())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseSimpleExpression();
if (!pExp1)
return nullptr;
@@ -279,13 +280,13 @@ CXFA_FMParser::ParseLogicalOrExpression() {
if (HasError() || !IncrementParseDepthAndCheck())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseLogicalAndExpression();
if (!e1)
return nullptr;
for (;;) {
- switch (m_token->m_type) {
+ switch (m_token.m_type) {
case TOKor:
case TOKksor: {
if (!NextToken())
@@ -314,13 +315,13 @@ CXFA_FMParser::ParseLogicalAndExpression() {
if (HasError() || !IncrementParseDepthAndCheck())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseEqualityExpression();
if (!e1)
return nullptr;
for (;;) {
- switch (m_token->m_type) {
+ switch (m_token.m_type) {
case TOKand:
case TOKksand: {
if (!NextToken())
@@ -348,13 +349,13 @@ CXFA_FMParser::ParseEqualityExpression() {
if (HasError() || !IncrementParseDepthAndCheck())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseRelationalExpression();
if (!e1)
return nullptr;
for (;;) {
std::unique_ptr<CXFA_FMSimpleExpression> e2;
- switch (m_token->m_type) {
+ switch (m_token.m_type) {
case TOKeq:
case TOKkseq:
if (!NextToken())
@@ -393,14 +394,14 @@ CXFA_FMParser::ParseRelationalExpression() {
if (HasError() || !IncrementParseDepthAndCheck())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseAddtiveExpression();
if (!e1)
return nullptr;
for (;;) {
std::unique_ptr<CXFA_FMSimpleExpression> e2;
- switch (m_token->m_type) {
+ switch (m_token.m_type) {
case TOKlt:
case TOKkslt:
if (!NextToken())
@@ -463,14 +464,14 @@ CXFA_FMParser::ParseAddtiveExpression() {
if (HasError() || !IncrementParseDepthAndCheck())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseMultiplicativeExpression();
if (!e1)
return nullptr;
for (;;) {
std::unique_ptr<CXFA_FMSimpleExpression> e2;
- switch (m_token->m_type) {
+ switch (m_token.m_type) {
case TOKplus:
if (!NextToken())
return nullptr;
@@ -507,14 +508,14 @@ CXFA_FMParser::ParseMultiplicativeExpression() {
if (HasError() || !IncrementParseDepthAndCheck())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseUnaryExpression();
if (!e1)
return nullptr;
for (;;) {
std::unique_ptr<CXFA_FMSimpleExpression> e2;
- switch (m_token->m_type) {
+ switch (m_token.m_type) {
case TOKmul:
if (!NextToken())
return nullptr;
@@ -551,8 +552,8 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParseUnaryExpression() {
return nullptr;
std::unique_ptr<CXFA_FMSimpleExpression> expr;
- uint32_t line = m_token->m_line_num;
- switch (m_token->m_type) {
+ uint32_t line = m_lexer->GetCurrentLine();
+ switch (m_token.m_type) {
case TOKplus:
if (!NextToken())
return nullptr;
@@ -599,25 +600,25 @@ CXFA_FMParser::ParsePrimaryExpression() {
return nullptr;
std::unique_ptr<CXFA_FMSimpleExpression> expr;
- uint32_t line = m_token->m_line_num;
- switch (m_token->m_type) {
+ uint32_t line = m_lexer->GetCurrentLine();
+ switch (m_token.m_type) {
case TOKnumber:
expr =
- pdfium::MakeUnique<CXFA_FMNumberExpression>(line, m_token->m_string);
+ pdfium::MakeUnique<CXFA_FMNumberExpression>(line, m_token.m_string);
if (!NextToken())
return nullptr;
break;
case TOKstring:
expr =
- pdfium::MakeUnique<CXFA_FMStringExpression>(line, m_token->m_string);
+ pdfium::MakeUnique<CXFA_FMStringExpression>(line, m_token.m_string);
if (!NextToken())
return nullptr;
break;
case TOKidentifier: {
- WideStringView wsIdentifier(m_token->m_string);
+ WideStringView wsIdentifier(m_token.m_string);
if (!NextToken())
return nullptr;
- if (m_token->m_type == TOKlbracket) {
+ if (m_token.m_type == TOKlbracket) {
std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
if (!s)
return nullptr;
@@ -636,7 +637,7 @@ CXFA_FMParser::ParsePrimaryExpression() {
}
case TOKif:
expr = pdfium::MakeUnique<CXFA_FMIdentifierExpression>(line,
- m_token->m_string);
+ m_token.m_string);
if (!expr || !NextToken())
return nullptr;
break;
@@ -669,7 +670,7 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParsePostExpression(
if (HasError())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
size_t expr_count = 0;
while (1) {
++expr_count;
@@ -679,28 +680,28 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParsePostExpression(
if (expr_count > kMaxPostExpressions)
return nullptr;
- switch (m_token->m_type) {
+ switch (m_token.m_type) {
case TOKlparen: {
if (!NextToken())
return nullptr;
std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> expressions;
- if (m_token->m_type != TOKrparen) {
- while (m_token->m_type != TOKrparen) {
+ if (m_token.m_type != TOKrparen) {
+ while (m_token.m_type != TOKrparen) {
std::unique_ptr<CXFA_FMSimpleExpression> simple_expr =
ParseSimpleExpression();
if (!simple_expr)
return nullptr;
expressions.push_back(std::move(simple_expr));
- if (m_token->m_type == TOKcomma) {
+ if (m_token.m_type == TOKcomma) {
if (!NextToken())
return nullptr;
- } else if (m_token->m_type == TOKeof ||
- m_token->m_type == TOKreserver) {
+ } else if (m_token.m_type == TOKeof ||
+ m_token.m_type == TOKreserver) {
break;
}
}
- if (m_token->m_type != TOKrparen) {
+ if (m_token.m_type != TOKrparen) {
m_error = true;
return nullptr;
}
@@ -709,7 +710,7 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParsePostExpression(
line, std::move(expr), std::move(expressions), false);
if (!NextToken())
return nullptr;
- if (m_token->m_type != TOKlbracket)
+ if (m_token.m_type != TOKlbracket)
continue;
std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
@@ -723,37 +724,37 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParsePostExpression(
case TOKdot: {
if (!NextToken())
return nullptr;
- if (m_token->m_type != TOKidentifier) {
+ if (m_token.m_type != TOKidentifier) {
m_error = true;
return nullptr;
}
- WideStringView tempStr = m_token->m_string;
- uint32_t tempLine = m_token->m_line_num;
+ WideStringView tempStr = m_token.m_string;
+ uint32_t tempLine = m_lexer->GetCurrentLine();
if (!NextToken())
return nullptr;
- if (m_token->m_type == TOKlparen) {
+ if (m_token.m_type == TOKlparen) {
std::unique_ptr<CXFA_FMSimpleExpression> pExpCall;
if (!NextToken())
return nullptr;
std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> expressions;
- if (m_token->m_type != TOKrparen) {
- while (m_token->m_type != TOKrparen) {
+ if (m_token.m_type != TOKrparen) {
+ while (m_token.m_type != TOKrparen) {
std::unique_ptr<CXFA_FMSimpleExpression> exp =
ParseSimpleExpression();
if (!exp)
return nullptr;
expressions.push_back(std::move(exp));
- if (m_token->m_type == TOKcomma) {
+ if (m_token.m_type == TOKcomma) {
if (!NextToken())
return nullptr;
- } else if (m_token->m_type == TOKeof ||
- m_token->m_type == TOKreserver) {
+ } else if (m_token.m_type == TOKeof ||
+ m_token.m_type == TOKreserver) {
break;
}
}
- if (m_token->m_type != TOKrparen) {
+ if (m_token.m_type != TOKrparen) {
m_error = true;
return nullptr;
}
@@ -767,7 +768,7 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParsePostExpression(
line, std::move(expr), std::move(pExpCall));
if (!NextToken())
return nullptr;
- if (m_token->m_type != TOKlbracket)
+ if (m_token.m_type != TOKlbracket)
continue;
std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
@@ -776,7 +777,7 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParsePostExpression(
expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
line, std::move(expr), TOKcall, L"", std::move(s));
- } else if (m_token->m_type == TOKlbracket) {
+ } else if (m_token.m_type == TOKlbracket) {
std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
if (!s)
return nullptr;
@@ -795,15 +796,15 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParsePostExpression(
case TOKdotdot: {
if (!NextToken())
return nullptr;
- if (m_token->m_type != TOKidentifier) {
+ if (m_token.m_type != TOKidentifier) {
m_error = true;
return nullptr;
}
- WideStringView tempStr = m_token->m_string;
- uint32_t tempLine = m_token->m_line_num;
+ WideStringView tempStr = m_token.m_string;
+ uint32_t tempLine = m_lexer->GetCurrentLine();
if (!NextToken())
return nullptr;
- if (m_token->m_type == TOKlbracket) {
+ if (m_token.m_type == TOKlbracket) {
std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
if (!s)
return nullptr;
@@ -822,15 +823,15 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParsePostExpression(
case TOKdotscream: {
if (!NextToken())
return nullptr;
- if (m_token->m_type != TOKidentifier) {
+ if (m_token.m_type != TOKidentifier) {
m_error = true;
return nullptr;
}
- WideStringView tempStr = m_token->m_string;
- uint32_t tempLine = m_token->m_line_num;
+ WideStringView tempStr = m_token.m_string;
+ uint32_t tempLine = m_lexer->GetCurrentLine();
if (!NextToken())
return nullptr;
- if (m_token->m_type != TOKlbracket) {
+ if (m_token.m_type != TOKlbracket) {
std::unique_ptr<CXFA_FMSimpleExpression> s =
pdfium::MakeUnique<CXFA_FMIndexExpression>(
tempLine, ACCESSOR_NO_INDEX, nullptr, false);
@@ -868,29 +869,29 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParseIndexExpression() {
if (HasError() || !IncrementParseDepthAndCheck())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
if (!NextToken())
return nullptr;
std::unique_ptr<CXFA_FMSimpleExpression> s;
XFA_FM_AccessorIndex accessorIndex = ACCESSOR_NO_RELATIVEINDEX;
std::unique_ptr<CXFA_FMSimpleExpression> pExp;
- if (m_token->m_type == TOKmul) {
+ if (m_token.m_type == TOKmul) {
pExp = pdfium::MakeUnique<CXFA_FMIndexExpression>(line, accessorIndex,
std::move(s), true);
if (!pExp || !NextToken())
return nullptr;
- if (m_token->m_type != TOKrbracket) {
+ if (m_token.m_type != TOKrbracket) {
m_error = true;
return nullptr;
}
return pExp;
}
- if (m_token->m_type == TOKplus) {
+ if (m_token.m_type == TOKplus) {
accessorIndex = ACCESSOR_POSITIVE_INDEX;
if (!NextToken())
return nullptr;
- } else if (m_token->m_type == TOKminus) {
+ } else if (m_token.m_type == TOKminus) {
accessorIndex = ACCESSOR_NEGATIVE_INDEX;
if (!NextToken())
return nullptr;
@@ -898,7 +899,7 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParseIndexExpression() {
s = ParseSimpleExpression();
if (!s)
return nullptr;
- if (m_token->m_type != TOKrbracket) {
+ if (m_token.m_type != TOKrbracket) {
m_error = true;
return nullptr;
}
@@ -914,18 +915,18 @@ std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParser::ParseParenExpression() {
if (!CheckThenNext(TOKlparen))
return nullptr;
- if (m_token->m_type == TOKrparen) {
+ if (m_token.m_type == TOKrparen) {
m_error = true;
return nullptr;
}
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression();
if (!pExp1)
return nullptr;
int level = 1;
- while (m_token->m_type == TOKassign) {
+ while (m_token.m_type == TOKassign) {
if (!NextToken())
return nullptr;
@@ -953,11 +954,11 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseBlockExpression() {
if (HasError())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
std::vector<std::unique_ptr<CXFA_FMExpression>> expressions;
while (1) {
std::unique_ptr<CXFA_FMExpression> expr;
- switch (m_token->m_type) {
+ switch (m_token.m_type) {
case TOKeof:
case TOKendif:
case TOKelseif:
@@ -994,29 +995,28 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseIfExpression() {
if (HasError() || !IncrementParseDepthAndCheck())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
const wchar_t* pStartPos = m_lexer->GetPos();
if (!NextToken() || !CheckThenNext(TOKlparen))
return nullptr;
std::unique_ptr<CXFA_FMSimpleExpression> pExpression;
- while (m_token->m_type != TOKrparen) {
+ while (m_token.m_type != TOKrparen) {
pExpression = ParseSimpleExpression();
if (!pExpression)
return nullptr;
- if (m_token->m_type != TOKcomma)
+ if (m_token.m_type != TOKcomma)
break;
if (!NextToken())
return nullptr;
}
if (!CheckThenNext(TOKrparen))
return nullptr;
- if (m_token->m_type != TOKthen) {
+ if (m_token.m_type != TOKthen) {
m_lexer->SetCurrentLine(line);
- auto pNewToken = pdfium::MakeUnique<CXFA_FMToken>(line);
- m_token = std::move(pNewToken);
- m_token->m_type = TOKidentifier;
- m_token->m_string = L"if";
+
+ m_token = CXFA_FMToken(TOKidentifier);
+ m_token.m_string = L"if";
m_lexer->SetPos(pStartPos);
return ParseExpExpression();
}
@@ -1028,7 +1028,7 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseIfExpression() {
return nullptr;
std::unique_ptr<CXFA_FMExpression> pElseExpression;
- switch (m_token->m_type) {
+ switch (m_token.m_type) {
case TOKeof:
case TOKendif:
if (!CheckThenNext(TOKendif))
@@ -1065,7 +1065,7 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseWhileExpression() {
if (HasError() || !IncrementParseDepthAndCheck())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
if (!NextToken())
return nullptr;
@@ -1089,7 +1089,7 @@ CXFA_FMParser::ParseSubassignmentInForExpression() {
if (HasError())
return nullptr;
- if (m_token->m_type != TOKidentifier) {
+ if (m_token.m_type != TOKidentifier) {
m_error = true;
return nullptr;
}
@@ -1105,18 +1105,18 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseForExpression() {
return nullptr;
WideStringView wsVariant;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
if (!NextToken())
return nullptr;
- if (m_token->m_type != TOKidentifier) {
+ if (m_token.m_type != TOKidentifier) {
m_error = true;
return nullptr;
}
- wsVariant = m_token->m_string;
+ wsVariant = m_token.m_string;
if (!NextToken())
return nullptr;
- if (m_token->m_type != TOKassign) {
+ if (m_token.m_type != TOKassign) {
m_error = true;
return nullptr;
}
@@ -1129,9 +1129,9 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseForExpression() {
return nullptr;
int32_t iDirection = 0;
- if (m_token->m_type == TOKupto) {
+ if (m_token.m_type == TOKupto) {
iDirection = 1;
- } else if (m_token->m_type == TOKdownto) {
+ } else if (m_token.m_type == TOKdownto) {
iDirection = -1;
} else {
m_error = true;
@@ -1146,7 +1146,7 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseForExpression() {
return nullptr;
std::unique_ptr<CXFA_FMSimpleExpression> pStep;
- if (m_token->m_type == TOKstep) {
+ if (m_token.m_type == TOKstep) {
if (!NextToken())
return nullptr;
pStep = ParseSimpleExpression();
@@ -1180,29 +1180,29 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseForeachExpression() {
WideStringView wsIdentifier;
std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> pAccessors;
std::unique_ptr<CXFA_FMExpression> pList;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
if (!NextToken())
return nullptr;
- if (m_token->m_type != TOKidentifier) {
+ if (m_token.m_type != TOKidentifier) {
m_error = true;
return nullptr;
}
- wsIdentifier = m_token->m_string;
+ wsIdentifier = m_token.m_string;
if (!NextToken() || !CheckThenNext(TOKin) || !CheckThenNext(TOKlparen))
return nullptr;
- if (m_token->m_type == TOKrparen) {
+ if (m_token.m_type == TOKrparen) {
m_error = true;
return nullptr;
}
- while (m_token->m_type != TOKrparen) {
+ while (m_token.m_type != TOKrparen) {
std::unique_ptr<CXFA_FMSimpleExpression> s = ParseSimpleExpression();
if (!s)
return nullptr;
pAccessors.push_back(std::move(s));
- if (m_token->m_type != TOKcomma)
+ if (m_token.m_type != TOKcomma)
break;
if (!NextToken())
return nullptr;
@@ -1225,7 +1225,7 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseDoExpression() {
if (HasError())
return nullptr;
- uint32_t line = m_token->m_line_num;
+ uint32_t line = m_lexer->GetCurrentLine();
if (!NextToken())
return nullptr;
@@ -1236,5 +1236,5 @@ std::unique_ptr<CXFA_FMExpression> CXFA_FMParser::ParseDoExpression() {
}
bool CXFA_FMParser::HasError() const {
- return m_error || m_token == nullptr;
+ return m_error || m_token.m_type == TOKreserver;
}
diff --git a/xfa/fxfa/fm2js/cxfa_fmparser.h b/xfa/fxfa/fm2js/cxfa_fmparser.h
index c536838a3c..3958930224 100644
--- a/xfa/fxfa/fm2js/cxfa_fmparser.h
+++ b/xfa/fxfa/fm2js/cxfa_fmparser.h
@@ -57,7 +57,7 @@ class CXFA_FMParser {
std::unique_ptr<CXFA_FMSimpleExpression> ParseIndexExpression();
std::unique_ptr<CXFA_FMLexer> m_lexer;
- std::unique_ptr<CXFA_FMToken> m_token;
+ CXFA_FMToken m_token;
bool m_error;
unsigned long m_parse_depth;
unsigned long m_max_parse_depth;
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-05 01:13:28 +0000