Remove FX_DWORD from XFA.

xfa/fxfa/fm2js/xfa_simpleexpression.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_simpleexpression.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 
@@ skipping 63 matching lines @@
     {0xd907aee5, L"Num2GMTime"},   {0xdf24f7c4, L"Decode"},
     {0xe2664803, L"Substr"},       {0xe3e7b528, L"Stuff"},
     {0xe6792d4e, L"Rtrim"},        {0xe8c23f5b, L"Parse"},
     {0xea18d121, L"Choose"},       {0xebfef69c, L"Replace"},
     {0xf5ad782b, L"Left"},         {0xf7bb2248, L"Ltrim"},
 };
 
 struct XFA_FMSOMMethod {
   uint32_t m_uHash;
   const FX_WCHAR* m_wsSomMethodName;
-  FX_DWORD m_dParameters;
+  uint32_t m_dParameters;
 };
 const XFA_FMSOMMethod gs_FMSomMethods[] = {
     {0x00000068, L"h", 0x01},
     {0x00000077, L"w", 0x01},
     {0x00000078, L"x", 0x01},
     {0x00000079, L"y", 0x01},
     {0x05eb5b0f, L"pageSpan", 0x01},
     {0x10f1b1bd, L"page", 0x01},
     {0x3bf1c2a5, L"absPageSpan", 0x01},
     {0x3c752495, L"verify", 0x0d},
@@ skipping 12 matching lines @@
     {0xe74f0653, L"absPage", 0x01},
 };
 
 }  // namespace
 
 CFX_WideStringC XFA_FM_EXPTypeToString(
     XFA_FM_SimpleExpressionType simpleExpType) {
   return gs_lpStrExpFuncName[simpleExpType];
 }
 
-CXFA_FMSimpleExpression::CXFA_FMSimpleExpression(FX_DWORD line, XFA_FM_TOKEN op)
+CXFA_FMSimpleExpression::CXFA_FMSimpleExpression(uint32_t line, XFA_FM_TOKEN op)
     : m_line(line), m_op(op) {}
 
 void CXFA_FMSimpleExpression::ToJavaScript(CFX_WideTextBuf& javascript) {}
 
 void CXFA_FMSimpleExpression::ToImpliedReturnJS(CFX_WideTextBuf& javascript) {}
 
 XFA_FM_TOKEN CXFA_FMSimpleExpression::GetOperatorToken() const {
   return m_op;
 }
 
-CXFA_FMNullExpression::CXFA_FMNullExpression(FX_DWORD line)
+CXFA_FMNullExpression::CXFA_FMNullExpression(uint32_t line)
     : CXFA_FMSimpleExpression(line, TOKnull) {}
 
 void CXFA_FMNullExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << FX_WSTRC(L"null");
 }
 
-CXFA_FMNumberExpression::CXFA_FMNumberExpression(FX_DWORD line,
+CXFA_FMNumberExpression::CXFA_FMNumberExpression(uint32_t line,
                                                  CFX_WideStringC wsNumber)
     : CXFA_FMSimpleExpression(line, TOKnumber), m_wsNumber(wsNumber) {}
 
 void CXFA_FMNumberExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << m_wsNumber;
 }
 
-CXFA_FMStringExpression::CXFA_FMStringExpression(FX_DWORD line,
+CXFA_FMStringExpression::CXFA_FMStringExpression(uint32_t line,
                                                  CFX_WideStringC wsString)
     : CXFA_FMSimpleExpression(line, TOKstring), m_wsString(wsString) {}
 
 void CXFA_FMStringExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   CFX_WideString tempStr = m_wsString;
   if (tempStr.GetLength() > 2) {
     javascript.AppendChar(L'\"');
     FX_WCHAR oneChar;
     for (int16_t i = 1; i < tempStr.GetLength() - 1; i++) {
       oneChar = tempStr[i];
@@ skipping 10 matching lines @@
         default: { javascript.AppendChar(oneChar); } break;
       }
     }
     javascript.AppendChar(L'\"');
   } else {
     javascript << tempStr;
   }
 }
 
 CXFA_FMIdentifierExpressionn::CXFA_FMIdentifierExpressionn(
-    FX_DWORD line,
+    uint32_t line,
     CFX_WideStringC wsIdentifier)
     : CXFA_FMSimpleExpression(line, TOKidentifier),
       m_wsIdentifier(wsIdentifier) {}
 
 void CXFA_FMIdentifierExpressionn::ToJavaScript(CFX_WideTextBuf& javascript) {
   CFX_WideString tempStr = m_wsIdentifier;
   if (tempStr.Equal(FX_WSTRC(L"$"))) {
     tempStr = FX_WSTRC(L"this");
   } else if (tempStr.Equal(FX_WSTRC(L"!"))) {
     tempStr = FX_WSTRC(L"xfa.datasets");
   } else if (tempStr.Equal(FX_WSTRC(L"$data"))) {
     tempStr = FX_WSTRC(L"xfa.datasets.data");
   } else if (tempStr.Equal(FX_WSTRC(L"$event"))) {
     tempStr = FX_WSTRC(L"xfa.event");
   } else if (tempStr.Equal(FX_WSTRC(L"$form"))) {
     tempStr = FX_WSTRC(L"xfa.form");
   } else if (tempStr.Equal(FX_WSTRC(L"$host"))) {
     tempStr = FX_WSTRC(L"xfa.host");
   } else if (tempStr.Equal(FX_WSTRC(L"$layout"))) {
     tempStr = FX_WSTRC(L"xfa.layout");
   } else if (tempStr.Equal(FX_WSTRC(L"$template"))) {
     tempStr = FX_WSTRC(L"xfa.template");
   } else if (tempStr[0] == L'!') {
     tempStr = EXCLAMATION_IN_IDENTIFIER + tempStr.Mid(1);
   }
   javascript << tempStr;
 }
 
-CXFA_FMUnaryExpression::CXFA_FMUnaryExpression(FX_DWORD line,
+CXFA_FMUnaryExpression::CXFA_FMUnaryExpression(uint32_t line,
                                                XFA_FM_TOKEN op,
                                                CXFA_FMSimpleExpression* pExp)
     : CXFA_FMSimpleExpression(line, op), m_pExp(pExp) {}
 
 void CXFA_FMUnaryExpression::ToJavaScript(CFX_WideTextBuf& javascript) {}
 
-CXFA_FMBinExpression::CXFA_FMBinExpression(FX_DWORD line,
+CXFA_FMBinExpression::CXFA_FMBinExpression(uint32_t line,
                                            XFA_FM_TOKEN op,
                                            CXFA_FMSimpleExpression* pExp1,
                                            CXFA_FMSimpleExpression* pExp2)
     : CXFA_FMSimpleExpression(line, op), m_pExp1(pExp1), m_pExp2(pExp2) {}
 
 void CXFA_FMBinExpression::ToJavaScript(CFX_WideTextBuf& javascript) {}
 
-CXFA_FMAssignExpression::CXFA_FMAssignExpression(FX_DWORD line,
+CXFA_FMAssignExpression::CXFA_FMAssignExpression(uint32_t line,
                                                  XFA_FM_TOKEN op,
                                                  CXFA_FMSimpleExpression* pExp1,
                                                  CXFA_FMSimpleExpression* pExp2)
     : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
 
 void CXFA_FMAssignExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << FX_WSTRC(L"if (");
   javascript << gs_lpStrExpFuncName[ISFMOBJECT];
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
@@ skipping 46 matching lines @@
     javascript << gs_lpStrExpFuncName[ASSIGN];
     javascript << FX_WSTRC(L"(");
     m_pExp1->ToJavaScript(javascript);
     javascript << FX_WSTRC(L", ");
     m_pExp2->ToJavaScript(javascript);
     javascript << FX_WSTRC(L");\n}\n");
   }
 }
 
 CXFA_FMLogicalOrExpression::CXFA_FMLogicalOrExpression(
-    FX_DWORD line,
+    uint32_t line,
     XFA_FM_TOKEN op,
     CXFA_FMSimpleExpression* pExp1,
     CXFA_FMSimpleExpression* pExp2)
     : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
 
 void CXFA_FMLogicalOrExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[LOGICALOR];
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMLogicalAndExpression::CXFA_FMLogicalAndExpression(
-    FX_DWORD line,
+    uint32_t line,
     XFA_FM_TOKEN op,
     CXFA_FMSimpleExpression* pExp1,
     CXFA_FMSimpleExpression* pExp2)
     : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
 
 void CXFA_FMLogicalAndExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[LOGICALAND];
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMEqualityExpression::CXFA_FMEqualityExpression(
-    FX_DWORD line,
+    uint32_t line,
     XFA_FM_TOKEN op,
     CXFA_FMSimpleExpression* pExp1,
     CXFA_FMSimpleExpression* pExp2)
     : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
 
 void CXFA_FMEqualityExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   switch (m_op) {
     case TOKeq:
     case TOKkseq:
       javascript << gs_lpStrExpFuncName[EQUALITY];
       break;
     case TOKne:
     case TOKksne:
       javascript << gs_lpStrExpFuncName[NOTEQUALITY];
       break;
     default:
       FXSYS_assert(FALSE);
       break;
   }
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMRelationalExpression::CXFA_FMRelationalExpression(
-    FX_DWORD line,
+    uint32_t line,
     XFA_FM_TOKEN op,
     CXFA_FMSimpleExpression* pExp1,
     CXFA_FMSimpleExpression* pExp2)
     : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
 
 void CXFA_FMRelationalExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   switch (m_op) {
     case TOKlt:
     case TOKkslt:
       javascript << gs_lpStrExpFuncName[LESS];
@@ skipping 15 matching lines @@
       break;
   }
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMAdditiveExpression::CXFA_FMAdditiveExpression(
-    FX_DWORD line,
+    uint32_t line,
     XFA_FM_TOKEN op,
     CXFA_FMSimpleExpression* pExp1,
     CXFA_FMSimpleExpression* pExp2)
     : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
 
 void CXFA_FMAdditiveExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   switch (m_op) {
     case TOKplus:
       javascript << gs_lpStrExpFuncName[PLUS];
       break;
     case TOKminus:
       javascript << gs_lpStrExpFuncName[MINUS];
       break;
     default:
       FXSYS_assert(FALSE);
       break;
   }
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMMultiplicativeExpression::CXFA_FMMultiplicativeExpression(
-    FX_DWORD line,
+    uint32_t line,
     XFA_FM_TOKEN op,
     CXFA_FMSimpleExpression* pExp1,
     CXFA_FMSimpleExpression* pExp2)
     : CXFA_FMBinExpression(line, op, pExp1, pExp2) {}
 
 void CXFA_FMMultiplicativeExpression::ToJavaScript(
     CFX_WideTextBuf& javascript) {
   switch (m_op) {
     case TOKmul:
       javascript << gs_lpStrExpFuncName[MULTIPLE];
       break;
     case TOKdiv:
       javascript << gs_lpStrExpFuncName[DIVIDE];
       break;
     default:
       FXSYS_assert(FALSE);
       break;
   }
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
-CXFA_FMPosExpression::CXFA_FMPosExpression(FX_DWORD line,
+CXFA_FMPosExpression::CXFA_FMPosExpression(uint32_t line,
                                            CXFA_FMSimpleExpression* pExp)
     : CXFA_FMUnaryExpression(line, TOKplus, pExp) {}
 
 void CXFA_FMPosExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[POSITIVE];
   javascript << FX_WSTRC(L"(");
   m_pExp->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
-CXFA_FMNegExpression::CXFA_FMNegExpression(FX_DWORD line,
+CXFA_FMNegExpression::CXFA_FMNegExpression(uint32_t line,
                                            CXFA_FMSimpleExpression* pExp)
     : CXFA_FMUnaryExpression(line, TOKminus, pExp) {}
 
 void CXFA_FMNegExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[NEGATIVE];
   javascript << FX_WSTRC(L"(");
   m_pExp->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
-CXFA_FMNotExpression::CXFA_FMNotExpression(FX_DWORD line,
+CXFA_FMNotExpression::CXFA_FMNotExpression(uint32_t line,
                                            CXFA_FMSimpleExpression* pExp)
     : CXFA_FMUnaryExpression(line, TOKksnot, pExp) {}
 
 void CXFA_FMNotExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[NOT];
   javascript << FX_WSTRC(L"(");
   m_pExp->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
-CXFA_FMCallExpression::CXFA_FMCallExpression(FX_DWORD line,
+CXFA_FMCallExpression::CXFA_FMCallExpression(uint32_t line,
                                              CXFA_FMSimpleExpression* pExp,
                                              CFX_PtrArray* pArguments,
                                              FX_BOOL bIsSomMethod)
     : CXFA_FMUnaryExpression(line, TOKcall, pExp),
       m_bIsSomMethod(bIsSomMethod),
       m_pArguments(pArguments) {}
 
 CXFA_FMCallExpression::~CXFA_FMCallExpression() {
   if (m_pArguments) {
     for (int i = 0; i < m_pArguments->GetSize(); ++i) {
@@ skipping 14 matching lines @@
                          return func.m_uHash < hash;
                        });
   if (pFunc < pEnd && uHash == pFunc->m_uHash) {
     funcName->Clear();
     *funcName << pFunc->m_buildinfunc;
     return true;
   }
   return false;
 }
 
-FX_DWORD CXFA_FMCallExpression::IsMethodWithObjParam(
+uint32_t CXFA_FMCallExpression::IsMethodWithObjParam(
     const CFX_WideStringC& methodName) {
   int32_t iLength = methodName.GetLength();
   uint32_t uHash = FX_HashCode_String_GetW(methodName.GetPtr(), iLength);
   XFA_FMSOMMethod somMethodWithObjPara;
-  FX_DWORD parameters = 0x00;
+  uint32_t parameters = 0x00;
   int32_t iStart = 0,
           iEnd = (sizeof(gs_FMSomMethods) / sizeof(gs_FMSomMethods[0])) - 1;
   int32_t iMid = (iStart + iEnd) / 2;
   do {
     iMid = (iStart + iEnd) / 2;
     somMethodWithObjPara = gs_FMSomMethods[iMid];
     if (uHash == somMethodWithObjPara.m_uHash) {
       parameters = somMethodWithObjPara.m_dParameters;
       break;
     } else if (uHash < somMethodWithObjPara.m_uHash) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
   return parameters;
 }
 
 void CXFA_FMCallExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   CFX_WideTextBuf funcName;
   m_pExp->ToJavaScript(funcName);
   if (m_bIsSomMethod) {
     javascript << funcName;
     javascript << FX_WSTRC(L"(");
     if (m_pArguments) {
-      FX_DWORD methodPara = IsMethodWithObjParam(funcName.GetWideString());
+      uint32_t methodPara = IsMethodWithObjParam(funcName.GetWideString());
       if (methodPara > 0) {
         for (int i = 0; i < m_pArguments->GetSize(); ++i) {
           if ((methodPara & (0x01 << i)) > 0) {
             javascript << gs_lpStrExpFuncName[GETFMJSOBJ];
           } else {
             javascript << gs_lpStrExpFuncName[GETFMVALUE];
           }
           javascript << FX_WSTRC(L"(");
           CXFA_FMSimpleExpression* e =
               reinterpret_cast<CXFA_FMSimpleExpression*>(
@@ skipping 65 matching lines @@
       }
     }
     javascript << FX_WSTRC(L")");
     if (isEvalFunc) {
       javascript << FX_WSTRC(L")");
     }
   }
 }
 
 CXFA_FMDotAccessorExpression::CXFA_FMDotAccessorExpression(
-    FX_DWORD line,
+    uint32_t line,
     CXFA_FMSimpleExpression* pAccessor,
     XFA_FM_TOKEN op,
     CFX_WideStringC wsIdentifier,
     CXFA_FMSimpleExpression* pIndexExp)
     : CXFA_FMBinExpression(line, op, pAccessor, pIndexExp),
       m_wsIdentifier(wsIdentifier) {}
 
 void CXFA_FMDotAccessorExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[DOT];
   javascript << FX_WSTRC(L"(");
@@ skipping 19 matching lines @@
   } else {
     javascript << FX_WSTRC(L"\"");
     javascript << m_wsIdentifier;
     javascript << FX_WSTRC(L"\", ");
   }
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMIndexExpression::CXFA_FMIndexExpression(
-    FX_DWORD line,
+    uint32_t line,
     XFA_FM_AccessorIndex accessorIndex,
     CXFA_FMSimpleExpression* pIndexExp,
     FX_BOOL bIsStarIndex)
     : CXFA_FMUnaryExpression(line, TOKlbracket, pIndexExp),
       m_accessorIndex(accessorIndex),
       m_bIsStarIndex(bIsStarIndex) {}
 
 void CXFA_FMIndexExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   switch (m_accessorIndex) {
     case ACCESSOR_NO_INDEX:
@@ skipping 15 matching lines @@
     javascript << FX_WSTRC(L", ");
     if (m_pExp) {
       m_pExp->ToJavaScript(javascript);
     } else {
       javascript << FX_WSTRC(L"0");
     }
   }
 }
 
 CXFA_FMDotDotAccessorExpression::CXFA_FMDotDotAccessorExpression(
-    FX_DWORD line,
+    uint32_t line,
     CXFA_FMSimpleExpression* pAccessor,
     XFA_FM_TOKEN op,
     CFX_WideStringC wsIdentifier,
     CXFA_FMSimpleExpression* pIndexExp)
     : CXFA_FMBinExpression(line, op, pAccessor, pIndexExp),
       m_wsIdentifier(wsIdentifier) {}
 
 void CXFA_FMDotDotAccessorExpression::ToJavaScript(
     CFX_WideTextBuf& javascript) {
   javascript << gs_lpStrExpFuncName[DOTDOT];
   javascript << FX_WSTRC(L"(");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L", ");
   javascript << FX_WSTRC(L"\"");
   if (m_pExp1 && m_pExp1->GetOperatorToken() == TOKidentifier) {
     m_pExp1->ToJavaScript(javascript);
   }
   javascript << FX_WSTRC(L"\", ");
   javascript << FX_WSTRC(L"\"");
   javascript << m_wsIdentifier;
   javascript << FX_WSTRC(L"\", ");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L")");
 }
 
 CXFA_FMMethodCallExpression::CXFA_FMMethodCallExpression(
-    FX_DWORD line,
+    uint32_t line,
     CXFA_FMSimpleExpression* pAccessorExp1,
     CXFA_FMSimpleExpression* pCallExp)
     : CXFA_FMBinExpression(line, TOKdot, pAccessorExp1, pCallExp) {}
 
 void CXFA_FMMethodCallExpression::ToJavaScript(CFX_WideTextBuf& javascript) {
   javascript << FX_WSTRC(L"(\nfunction ()\n{\n");
   javascript << FX_WSTRC(L"var method_return_value = null;\n");
   javascript << FX_WSTRC(L"var accessor_object = ");
   m_pExp1->ToJavaScript(javascript);
   javascript << FX_WSTRC(L";\n");
   javascript << FX_WSTRC(L"if (");
   javascript << gs_lpStrExpFuncName[ISFMARRAY];
   javascript << FX_WSTRC(L"(accessor_object))\n{\n");
   javascript << FX_WSTRC(
       L"for(var index = accessor_object.length - 1; index > 1; index--)\n{\n");
   javascript << FX_WSTRC(L"method_return_value = accessor_object[index].");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L";\n}\n}\n");
   javascript << FX_WSTRC(L"else\n{\nmethod_return_value = accessor_object.");
   m_pExp2->ToJavaScript(javascript);
   javascript << FX_WSTRC(L";\n}\n");
   javascript << FX_WSTRC(L"return method_return_value;\n");
   javascript << FX_WSTRC(L"}\n).call(this)");
 }