Remove FX_DWORD from core/ and delete definition

core/fxcodec/jbig2/JBig2_SddProc.cpp

 // Copyright 2015 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 "core/fxcodec/jbig2/JBig2_SddProc.h"
 
 #include <memory>
 #include <vector>
 
 #include "core/fxcodec/jbig2/JBig2_ArithIntDecoder.h"
 #include "core/fxcodec/jbig2/JBig2_GrdProc.h"
 #include "core/fxcodec/jbig2/JBig2_GrrdProc.h"
 #include "core/fxcodec/jbig2/JBig2_HuffmanDecoder.h"
 #include "core/fxcodec/jbig2/JBig2_HuffmanTable.h"
 #include "core/fxcodec/jbig2/JBig2_HuffmanTable_Standard.h"
 #include "core/fxcodec/jbig2/JBig2_SymbolDict.h"
 #include "core/fxcodec/jbig2/JBig2_TrdProc.h"
 #include "core/fxcrt/include/fx_basic.h"
 
 CJBig2_SymbolDict* CJBig2_SDDProc::decode_Arith(
     CJBig2_ArithDecoder* pArithDecoder,
     std::vector<JBig2ArithCtx>* gbContext,
     std::vector<JBig2ArithCtx>* grContext) {
   CJBig2_Image** SDNEWSYMS;
-  FX_DWORD HCHEIGHT, NSYMSDECODED;
+  uint32_t HCHEIGHT, NSYMSDECODED;
   int32_t HCDH;
-  FX_DWORD SYMWIDTH, TOTWIDTH;
+  uint32_t SYMWIDTH, TOTWIDTH;
   int32_t DW;
   CJBig2_Image* BS;
-  FX_DWORD I, J, REFAGGNINST;
+  uint32_t I, J, REFAGGNINST;
   FX_BOOL* EXFLAGS;
-  FX_DWORD EXINDEX;
+  uint32_t EXINDEX;
   FX_BOOL CUREXFLAG;
-  FX_DWORD EXRUNLENGTH;
-  FX_DWORD nTmp;
-  FX_DWORD SBNUMSYMS;
+  uint32_t EXRUNLENGTH;
+  uint32_t nTmp;
+  uint32_t SBNUMSYMS;
   uint8_t SBSYMCODELEN;
   int32_t RDXI, RDYI;
   CJBig2_Image** SBSYMS;
   std::unique_ptr<CJBig2_ArithIaidDecoder> IAID;
   std::unique_ptr<CJBig2_SymbolDict> pDict;
   std::unique_ptr<CJBig2_ArithIntDecoder> IADH(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IADW(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IAAI(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IARDX(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IARDY(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IAEX(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IADT(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IAFS(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IADS(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IAIT(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IARI(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IARDW(new CJBig2_ArithIntDecoder);
   std::unique_ptr<CJBig2_ArithIntDecoder> IARDH(new CJBig2_ArithIntDecoder);
   nTmp = 0;
-  while ((FX_DWORD)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) {
+  while ((uint32_t)(1 << nTmp) < (SDNUMINSYMS + SDNUMNEWSYMS)) {
     nTmp++;
   }
   IAID.reset(new CJBig2_ArithIaidDecoder((uint8_t)nTmp));
   SDNEWSYMS = FX_Alloc(CJBig2_Image*, SDNUMNEWSYMS);
   FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*));
 
   HCHEIGHT = 0;
   NSYMSDECODED = 0;
   while (NSYMSDECODED < SDNUMNEWSYMS) {
     BS = nullptr;
@@ skipping 48 matching lines @@
           std::unique_ptr<CJBig2_TRDProc> pDecoder(new CJBig2_TRDProc());
           pDecoder->SBHUFF = SDHUFF;
           pDecoder->SBREFINE = 1;
           pDecoder->SBW = SYMWIDTH;
           pDecoder->SBH = HCHEIGHT;
           pDecoder->SBNUMINSTANCES = REFAGGNINST;
           pDecoder->SBSTRIPS = 1;
           pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
           SBNUMSYMS = pDecoder->SBNUMSYMS;
           nTmp = 0;
-          while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {
+          while ((uint32_t)(1 << nTmp) < SBNUMSYMS) {
             nTmp++;
           }
           SBSYMCODELEN = (uint8_t)nTmp;
           pDecoder->SBSYMCODELEN = SBSYMCODELEN;
           SBSYMS = FX_Alloc(CJBig2_Image*, SBNUMSYMS);
           JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
                        NSYMSDECODED * sizeof(CJBig2_Image*));
           pDecoder->SBSYMS = SBSYMS;
           pDecoder->SBDEFPIXEL = 0;
@@ skipping 47 matching lines @@
           ids.IARDY = IARDY.get();
           ids.IAID = IAID.get();
           BS = pDecoder->decode_Arith(pArithDecoder, grContext->data(), &ids);
           if (!BS) {
             FX_Free(SBSYMS);
             goto failed;
           }
           FX_Free(SBSYMS);
         } else if (REFAGGNINST == 1) {
           SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
-          FX_DWORD IDI;
+          uint32_t IDI;
           IAID->decode(pArithDecoder, &IDI);
           IARDX->decode(pArithDecoder, &RDXI);
           IARDY->decode(pArithDecoder, &RDYI);
           if (IDI >= SBNUMSYMS) {
             goto failed;
           }
           SBSYMS = FX_Alloc(CJBig2_Image*, SBNUMSYMS);
           JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
                        NSYMSDECODED * sizeof(CJBig2_Image*));
@@ skipping 70 matching lines @@
   FX_Free(SDNEWSYMS);
   return nullptr;
 }
 
 CJBig2_SymbolDict* CJBig2_SDDProc::decode_Huffman(
     CJBig2_BitStream* pStream,
     std::vector<JBig2ArithCtx>* gbContext,
     std::vector<JBig2ArithCtx>* grContext,
     IFX_Pause* pPause) {
   CJBig2_Image** SDNEWSYMS;
-  FX_DWORD* SDNEWSYMWIDTHS;
-  FX_DWORD HCHEIGHT, NSYMSDECODED;
+  uint32_t* SDNEWSYMWIDTHS;
+  uint32_t HCHEIGHT, NSYMSDECODED;
   int32_t HCDH;
-  FX_DWORD SYMWIDTH, TOTWIDTH, HCFIRSTSYM;
+  uint32_t SYMWIDTH, TOTWIDTH, HCFIRSTSYM;
   int32_t DW;
   CJBig2_Image *BS, *BHC;
-  FX_DWORD I, J, REFAGGNINST;
+  uint32_t I, J, REFAGGNINST;
   FX_BOOL* EXFLAGS;
-  FX_DWORD EXINDEX;
+  uint32_t EXINDEX;
   FX_BOOL CUREXFLAG;
-  FX_DWORD EXRUNLENGTH;
+  uint32_t EXRUNLENGTH;
   int32_t nVal, nBits;
-  FX_DWORD nTmp;
-  FX_DWORD SBNUMSYMS;
+  uint32_t nTmp;
+  uint32_t SBNUMSYMS;
   uint8_t SBSYMCODELEN;
   JBig2HuffmanCode* SBSYMCODES;
-  FX_DWORD IDI;
+  uint32_t IDI;
   int32_t RDXI, RDYI;
-  FX_DWORD BMSIZE;
-  FX_DWORD stride;
+  uint32_t BMSIZE;
+  uint32_t stride;
   CJBig2_Image** SBSYMS;
   std::unique_ptr<CJBig2_HuffmanDecoder> pHuffmanDecoder(
       new CJBig2_HuffmanDecoder(pStream));
   SDNEWSYMS = FX_Alloc(CJBig2_Image*, SDNUMNEWSYMS);
   FXSYS_memset(SDNEWSYMS, 0, SDNUMNEWSYMS * sizeof(CJBig2_Image*));
   SDNEWSYMWIDTHS = nullptr;
   BHC = nullptr;
   if (SDREFAGG == 0) {
-    SDNEWSYMWIDTHS = FX_Alloc(FX_DWORD, SDNUMNEWSYMS);
-    FXSYS_memset(SDNEWSYMWIDTHS, 0, SDNUMNEWSYMS * sizeof(FX_DWORD));
+    SDNEWSYMWIDTHS = FX_Alloc(uint32_t, SDNUMNEWSYMS);
+    FXSYS_memset(SDNEWSYMWIDTHS, 0, SDNUMNEWSYMS * sizeof(uint32_t));
   }
   std::unique_ptr<CJBig2_SymbolDict> pDict(new CJBig2_SymbolDict());
   std::unique_ptr<CJBig2_HuffmanTable> pTable;
 
   HCHEIGHT = 0;
   NSYMSDECODED = 0;
   BS = nullptr;
   while (NSYMSDECODED < SDNUMNEWSYMS) {
     if (pHuffmanDecoder->decodeAValue(SDHUFFDH, &HCDH) != 0) {
       goto failed;
@@ skipping 37 matching lines @@
           pDecoder->SBHUFF = SDHUFF;
           pDecoder->SBREFINE = 1;
           pDecoder->SBW = SYMWIDTH;
           pDecoder->SBH = HCHEIGHT;
           pDecoder->SBNUMINSTANCES = REFAGGNINST;
           pDecoder->SBSTRIPS = 1;
           pDecoder->SBNUMSYMS = SDNUMINSYMS + NSYMSDECODED;
           SBNUMSYMS = pDecoder->SBNUMSYMS;
           SBSYMCODES = FX_Alloc(JBig2HuffmanCode, SBNUMSYMS);
           nTmp = 1;
-          while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {
+          while ((uint32_t)(1 << nTmp) < SBNUMSYMS) {
             nTmp++;
           }
           for (I = 0; I < SBNUMSYMS; I++) {
             SBSYMCODES[I].codelen = nTmp;
             SBSYMCODES[I].code = I;
           }
           pDecoder->SBSYMCODES = SBSYMCODES;
           SBSYMS = FX_Alloc(CJBig2_Image*, SBNUMSYMS);
           JBIG2_memcpy(SBSYMS, SDINSYMS, SDNUMINSYMS * sizeof(CJBig2_Image*));
           JBIG2_memcpy(SBSYMS + SDNUMINSYMS, SDNEWSYMS,
@@ skipping 42 matching lines @@
           if (!BS) {
             FX_Free(SBSYMCODES);
             FX_Free(SBSYMS);
             goto failed;
           }
           FX_Free(SBSYMCODES);
           FX_Free(SBSYMS);
         } else if (REFAGGNINST == 1) {
           SBNUMSYMS = SDNUMINSYMS + SDNUMNEWSYMS;
           nTmp = 1;
-          while ((FX_DWORD)(1 << nTmp) < SBNUMSYMS) {
+          while ((uint32_t)(1 << nTmp) < SBNUMSYMS) {
             nTmp++;
           }
           SBSYMCODELEN = (uint8_t)nTmp;
           SBSYMCODES = FX_Alloc(JBig2HuffmanCode, SBNUMSYMS);
           for (I = 0; I < SBNUMSYMS; I++) {
             SBSYMCODES[I].codelen = SBSYMCODELEN;
             SBSYMCODES[I].code = I;
           }
           nVal = 0;
           nBits = 0;
@@ skipping 45 matching lines @@
           pGRRD->GRAT[3] = SDRAT[3];
           std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
               new CJBig2_ArithDecoder(pStream));
           BS = pGRRD->decode(pArithDecoder.get(), grContext->data());
           if (!BS) {
             FX_Free(SBSYMS);
             goto failed;
           }
           pStream->alignByte();
           pStream->offset(2);
-          if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
+          if ((uint32_t)nVal != (pStream->getOffset() - nTmp)) {
             delete BS;
             FX_Free(SBSYMS);
             goto failed;
           }
           FX_Free(SBSYMS);
         }
         SDNEWSYMS[NSYMSDECODED] = BS;
       }
       if (SDREFAGG == 0) {
         SDNEWSYMWIDTHS[NSYMSDECODED] = SYMWIDTH;
@@ skipping 84 matching lines @@
 failed:
   for (I = 0; I < NSYMSDECODED; I++) {
     delete SDNEWSYMS[I];
   }
   FX_Free(SDNEWSYMS);
   if (SDREFAGG == 0) {
     FX_Free(SDNEWSYMWIDTHS);
   }
   return nullptr;
 }