Remove FX_DWORD from XFA.

xfa/fxfa/fm2js/xfa_fmparse.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fxfa/fm2js/xfa_fmparse.h"
 
 #include <memory>
 
@@ skipping 18 matching lines @@
 
 void CXFA_FMParse::Check(XFA_FM_TOKEN op) {
   if (m_pToken->m_type != op) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
     Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
           XFA_FM_KeywordToString(op), ws_TempString.c_str());
   }
   NextToken();
 }
 
-void CXFA_FMParse::Error(FX_DWORD lineNum, XFA_FM_ERRMSG msg, ...) {
+void CXFA_FMParse::Error(uint32_t lineNum, XFA_FM_ERRMSG msg, ...) {
   m_pErrorInfo->linenum = lineNum;
   const FX_WCHAR* lpMessageInfo = XFA_FM_ErrorMsg(msg);
   va_list ap;
   va_start(ap, msg);
   m_pErrorInfo->message.FormatV(lpMessageInfo, ap);
   va_end(ap);
 }
 
 CFX_PtrArray* CXFA_FMParse::ParseTopExpression() {
   std::unique_ptr<CXFA_FMExpression> e;
@@ skipping 22 matching lines @@
     }
   }
   return expression;
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseFunction() {
   std::unique_ptr<CXFA_FMExpression> e;
   CFX_WideStringC ident;
   std::unique_ptr<CFX_WideStringCArray> pArguments;
   std::unique_ptr<CFX_PtrArray> pExpressions;
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
     Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
           ws_TempString.c_str());
   } else {
     ident = m_pToken->m_wstring;
     NextToken();
   }
   Check(TOKlparen);
@@ skipping 42 matching lines @@
     if (pExpressions) {
       for (int i = 0; i < pExpressions->GetSize(); ++i)
         delete static_cast<CXFA_FMExpression*>(pExpressions->GetAt(i));
     }
   }
   return e.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseExpression() {
   std::unique_ptr<CXFA_FMExpression> e;
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   switch (m_pToken->m_type) {
     case TOKvar:
       e.reset(ParseVarExpression());
       break;
     case TOKnull:
     case TOKnumber:
     case TOKstring:
     case TOKplus:
     case TOKminus:
     case TOKksnot:
@@ skipping 30 matching lines @@
             ws_TempString.c_str());
       NextToken();
       break;
   }
   return e.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseVarExpression() {
   std::unique_ptr<CXFA_FMExpression> e;
   CFX_WideStringC ident;
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
     Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
           ws_TempString.c_str());
   } else {
     ident = m_pToken->m_wstring;
     NextToken();
   }
   if (m_pToken->m_type == TOKassign) {
     NextToken();
     e.reset(ParseExpExpression());
   }
   if (m_pErrorInfo->message.IsEmpty()) {
     e.reset(new CXFA_FMVarExpression(line, ident, e.release()));
   } else {
     e.reset();
   }
   return e.release();
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseSimpleExpression() {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> pExp1(ParseLogicalOrExpression());
   while (m_pToken->m_type == TOKassign) {
     NextToken();
     std::unique_ptr<CXFA_FMSimpleExpression> pExp2(ParseLogicalOrExpression());
     if (m_pErrorInfo->message.IsEmpty()) {
       pExp1.reset(new CXFA_FMAssignExpression(line, TOKassign, pExp1.release(),
                                               pExp2.release()));
     } else {
       pExp1.reset();
     }
   }
   return pExp1.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseExpExpression() {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> pExp1(ParseSimpleExpression());
   std::unique_ptr<CXFA_FMExpression> e;
   if (m_pErrorInfo->message.IsEmpty()) {
     e.reset(new CXFA_FMExpExpression(line, pExp1.release()));
   } else {
     e.reset();
   }
   return e.release();
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalOrExpression() {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  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.reset(new CXFA_FMLogicalOrExpression(line, TOKor, e1.release(),
                                                   e2.release()));
         } else {
           e1.reset();
         }
         continue;
       }
       default:
         break;
     }
     break;
   }
   return e1.release();
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseLogicalAndExpression() {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  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.reset(new CXFA_FMLogicalAndExpression(line, TOKand, e1.release(),
                                                    e2.release()));
         } else {
           e1.reset();
         }
         continue;
       }
       default:
         break;
     }
     break;
   }
   return e1.release();
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseEqualityExpression() {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  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.reset(ParseRelationalExpression());
         if (m_pErrorInfo->message.IsEmpty()) {
           e1.reset(new CXFA_FMEqualityExpression(line, TOKeq, e1.release(),
@@ skipping 15 matching lines @@
         continue;
       default:
         break;
     }
     break;
   }
   return e1.release();
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseRelationalExpression() {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  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.reset(ParseAddtiveExpression());
         if (m_pErrorInfo->message.IsEmpty()) {
           e1.reset(new CXFA_FMRelationalExpression(line, TOKlt, e1.release(),
@@ skipping 37 matching lines @@
         continue;
       default:
         break;
     }
     break;
   }
   return e1.release();
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseAddtiveExpression() {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  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.reset(ParseMultiplicativeExpression());
         if (m_pErrorInfo->message.IsEmpty()) {
           e1.reset(new CXFA_FMAdditiveExpression(line, TOKplus, e1.release(),
                                                  e2.release()));
@@ skipping 13 matching lines @@
         continue;
       default:
         break;
     }
     break;
   }
   return e1.release();
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseMultiplicativeExpression() {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  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.reset(ParseUnaryExpression());
         if (m_pErrorInfo->message.IsEmpty()) {
           e1.reset(new CXFA_FMMultiplicativeExpression(
               line, TOKmul, e1.release(), e2.release()));
@@ skipping 14 matching lines @@
       default:
         break;
     }
     break;
   }
   return e1.release();
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseUnaryExpression() {
   std::unique_ptr<CXFA_FMSimpleExpression> e;
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   switch (m_pToken->m_type) {
     case TOKplus:
       NextToken();
       e.reset(ParseUnaryExpression());
       if (m_pErrorInfo->message.IsEmpty()) {
         e.reset(new CXFA_FMPosExpression(line, e.release()));
       } else {
         e.reset();
       }
       break;
@@ skipping 17 matching lines @@
       break;
     default:
       e.reset(ParsePrimaryExpression());
       break;
   }
   return e.release();
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParsePrimaryExpression() {
   std::unique_ptr<CXFA_FMSimpleExpression> e;
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   switch (m_pToken->m_type) {
     case TOKnumber:
       e.reset(new CXFA_FMNumberExpression(line, m_pToken->m_wstring));
       NextToken();
       break;
     case TOKstring:
       e.reset(new CXFA_FMStringExpression(line, m_pToken->m_wstring));
       NextToken();
       break;
     case TOKidentifier: {
@@ skipping 29 matching lines @@
       break;
   }
   e.reset(ParsePostExpression(e.release()));
   if (!(m_pErrorInfo->message.IsEmpty()))
     e.reset();
   return e.release();
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParsePostExpression(
     CXFA_FMSimpleExpression* e) {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   while (1) {
     switch (m_pToken->m_type) {
       case TOKlparen: {
         NextToken();
         std::unique_ptr<CFX_PtrArray> pArray;
         if (m_pToken->m_type != TOKrparen) {
           pArray.reset(new CFX_PtrArray());
           while (m_pToken->m_type != TOKrparen) {
             CXFA_FMSimpleExpression* e = ParseSimpleExpression();
             if (e) {
@@ skipping 32 matching lines @@
               delete static_cast<CXFA_FMSimpleExpression*>(pArray->GetAt(i));
           }
           delete e;
           e = nullptr;
         }
       } break;
       case TOKdot:
         NextToken();
         if (m_pToken->m_type == TOKidentifier) {
           CFX_WideStringC tempStr = m_pToken->m_wstring;
-          FX_DWORD tempLine = m_pToken->m_uLinenum;
+          uint32_t tempLine = m_pToken->m_uLinenum;
           NextToken();
           if (m_pToken->m_type == TOKlparen) {
             CXFA_FMSimpleExpression* pExpAccessor;
             CXFA_FMSimpleExpression* pExpCall;
             pExpAccessor = e;
             NextToken();
             std::unique_ptr<CFX_PtrArray> pArray;
             if (m_pToken->m_type != TOKrparen) {
               pArray.reset(new CFX_PtrArray());
               while (m_pToken->m_type != TOKrparen) {
@@ skipping 58 matching lines @@
           CFX_WideString ws_TempString = m_pToken->m_wstring;
           Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
                 ws_TempString.c_str());
           return e;
         }
         break;
       case TOKdotdot:
         NextToken();
         if (m_pToken->m_type == TOKidentifier) {
           CFX_WideStringC tempStr = m_pToken->m_wstring;
-          FX_DWORD tempLine = m_pToken->m_uLinenum;
+          uint32_t tempLine = m_pToken->m_uLinenum;
           NextToken();
           if (m_pToken->m_type == TOKlbracket) {
             std::unique_ptr<CXFA_FMSimpleExpression> s(ParseIndexExpression());
             if (!(m_pErrorInfo->message.IsEmpty())) {
               delete e;
               return nullptr;
             }
             e = new CXFA_FMDotDotAccessorExpression(tempLine, e, TOKdotdot,
                                                     tempStr, s.release());
           } else {
             CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression(
                 tempLine, ACCESSOR_NO_INDEX, NULL, FALSE);
             e = new CXFA_FMDotDotAccessorExpression(line, e, TOKdotdot, tempStr,
                                                     s);
             continue;
           }
         } else {
           CFX_WideString ws_TempString = m_pToken->m_wstring;
           Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
                 ws_TempString.c_str());
           return e;
         }
         break;
       case TOKdotscream:
         NextToken();
         if (m_pToken->m_type == TOKidentifier) {
           CFX_WideStringC tempStr = m_pToken->m_wstring;
-          FX_DWORD tempLine = m_pToken->m_uLinenum;
+          uint32_t tempLine = m_pToken->m_uLinenum;
           NextToken();
           if (m_pToken->m_type == TOKlbracket) {
             std::unique_ptr<CXFA_FMSimpleExpression> s(ParseIndexExpression());
             if (!(m_pErrorInfo->message.IsEmpty())) {
               delete e;
               return nullptr;
             }
             e = new CXFA_FMDotAccessorExpression(tempLine, e, TOKdotscream,
                                                  tempStr, s.release());
           } else {
@@ skipping 19 matching lines @@
       default:
         return e;
     }
     NextToken();
   }
   return e;
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseIndexExpression() {
   std::unique_ptr<CXFA_FMSimpleExpression> pExp;
-  FX_DWORD line = m_pToken->m_uLinenum;
+  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.reset(
         new CXFA_FMIndexExpression(line, accessorIndex, s.release(), TRUE));
     NextToken();
     if (m_pToken->m_type != TOKrbracket) {
       CFX_WideString ws_TempString = m_pToken->m_wstring;
       Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
@@ skipping 23 matching lines @@
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseParenExpression() {
   Check(TOKlparen);
 
   if (m_pToken->m_type == TOKrparen) {
     Error(m_pToken->m_uLinenum, FMERR_EXPECTED_NON_EMPTY_EXPRESSION);
     NextToken();
     return nullptr;
   }
 
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> pExp1(ParseLogicalOrExpression());
 
   while (m_pToken->m_type == TOKassign) {
     NextToken();
     std::unique_ptr<CXFA_FMSimpleExpression> pExp2(ParseLogicalOrExpression());
     if (m_pErrorInfo->message.IsEmpty()) {
       pExp1.reset(new CXFA_FMAssignExpression(line, TOKassign, pExp1.release(),
                                               pExp2.release()));
     } else {
       pExp1.reset();
     }
   }
   Check(TOKrparen);
   return pExp1.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseBlockExpression() {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   CXFA_FMExpression* e = nullptr;
   std::unique_ptr<CFX_PtrArray> expression(new CFX_PtrArray());
   while (1) {
     switch (m_pToken->m_type) {
       case TOKeof:
       case TOKendif:
       case TOKelseif:
       case TOKelse:
       case TOKendwhile:
       case TOKendfor:
@@ skipping 20 matching lines @@
   if (m_pErrorInfo->message.IsEmpty()) {
     pExp.reset(new CXFA_FMBlockExpression(line, expression.release()));
   } else {
     for (int i = 0; i < expression->GetSize(); ++i)
       delete static_cast<CXFA_FMExpression*>(expression->GetAt(i));
   }
   return pExp.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseIfExpression() {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   const FX_WCHAR* pStartPos = m_lexer->SavePos();
   NextToken();
   Check(TOKlparen);
   std::unique_ptr<CXFA_FMSimpleExpression> pExpression;
   while (m_pToken->m_type != TOKrparen) {
     pExpression.reset(ParseSimpleExpression());
     if (m_pToken->m_type != TOKcomma)
       break;
     NextToken();
   }
@@ skipping 36 matching lines @@
   std::unique_ptr<CXFA_FMIfExpression> pExp;
   if (m_pErrorInfo->message.IsEmpty()) {
     pExp.reset(new CXFA_FMIfExpression(line, pExpression.release(),
                                        pIfExpression.release(),
                                        pElseExpression.release()));
   }
   return pExp.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseWhileExpression() {
-  FX_DWORD line = m_pToken->m_uLinenum;
+  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> e;
   if (m_pErrorInfo->message.IsEmpty()) {
     e.reset(new CXFA_FMWhileExpression(line, pCondition.release(),
                                        pExpression.release()));
   }
@@ skipping 11 matching lines @@
       Error(m_pToken->m_uLinenum, FMERR_UNEXPECTED_EXPRESSION,
             ws_TempString.c_str());
       NextToken();
       break;
   }
   return e.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseForExpression() {
   CFX_WideStringC wsVariant;
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
     Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
           XFA_FM_KeywordToString(m_pToken->m_type), ws_TempString.c_str());
   }
   wsVariant = m_pToken->m_wstring;
   NextToken();
   std::unique_ptr<CXFA_FMSimpleExpression> pAssignment;
   if (m_pToken->m_type == TOKassign) {
@@ skipping 31 matching lines @@
                                      pStep.release(), pList.release()));
   }
   return e.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseForeachExpression() {
   std::unique_ptr<CXFA_FMExpression> e;
   CFX_WideStringC wsIdentifier;
   std::unique_ptr<CFX_PtrArray> pAccessors;
   std::unique_ptr<CXFA_FMExpression> pList;
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
     Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
           XFA_FM_KeywordToString(m_pToken->m_type), ws_TempString.c_str());
   }
   wsIdentifier = m_pToken->m_wstring;
   NextToken();
   Check(TOKin);
   Check(TOKlparen);
@@ skipping 27 matching lines @@
     if (pAccessors) {
       for (int i = 0; i < pAccessors->GetSize(); ++i)
         delete static_cast<CXFA_FMSimpleExpression*>(pAccessors->GetAt(i));
     }
   }
   return e.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseDoExpression() {
   std::unique_ptr<CXFA_FMExpression> e;
-  FX_DWORD line = m_pToken->m_uLinenum;
+  uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   e.reset(ParseBlockExpression());
   Check(TOKend);
   if (m_pErrorInfo->message.IsEmpty()) {
     e.reset(new CXFA_FMDoExpression(line, e.release()));
   } else {
     e.reset();
   }
   return e.release();
 }