Remove FX_DWORD from core/ and delete definition

core/fxcodec/codec/fx_codec_flate.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 "core/fxcodec/codec/codec_int.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 65 matching lines @@
   inflateEnd((z_stream*)context);
   ((z_stream*)context)->zfree(0, context);
 }
 }  // extern "C"
 
 namespace {
 
 class CLZWDecoder {
  public:
   int Decode(uint8_t* output,
-             FX_DWORD& outlen,
+             uint32_t& outlen,
              const uint8_t* input,
-             FX_DWORD& size,
+             uint32_t& size,
              FX_BOOL bEarlyChange);
 
  private:
-  void AddCode(FX_DWORD prefix_code, uint8_t append_char);
-  void DecodeString(FX_DWORD code);
+  void AddCode(uint32_t prefix_code, uint8_t append_char);
+  void DecodeString(uint32_t code);
 
-  FX_DWORD m_InPos;
-  FX_DWORD m_OutPos;
+  uint32_t m_InPos;
+  uint32_t m_OutPos;
   uint8_t* m_pOutput;
   const uint8_t* m_pInput;
   FX_BOOL m_Early;
-  FX_DWORD m_CodeArray[5021];
-  FX_DWORD m_nCodes;
+  uint32_t m_CodeArray[5021];
+  uint32_t m_nCodes;
   uint8_t m_DecodeStack[4000];
-  FX_DWORD m_StackLen;
+  uint32_t m_StackLen;
   int m_CodeLen;
 };
-void CLZWDecoder::AddCode(FX_DWORD prefix_code, uint8_t append_char) {
+void CLZWDecoder::AddCode(uint32_t prefix_code, uint8_t append_char) {
   if (m_nCodes + m_Early == 4094) {
     return;
   }
   m_CodeArray[m_nCodes++] = (prefix_code << 16) | append_char;
   if (m_nCodes + m_Early == 512 - 258) {
     m_CodeLen = 10;
   } else if (m_nCodes + m_Early == 1024 - 258) {
     m_CodeLen = 11;
   } else if (m_nCodes + m_Early == 2048 - 258) {
     m_CodeLen = 12;
   }
 }
-void CLZWDecoder::DecodeString(FX_DWORD code) {
+void CLZWDecoder::DecodeString(uint32_t code) {
   while (1) {
     int index = code - 258;
     if (index < 0 || index >= (int)m_nCodes) {
       break;
     }
-    FX_DWORD data = m_CodeArray[index];
+    uint32_t data = m_CodeArray[index];
     if (m_StackLen >= sizeof(m_DecodeStack)) {
       return;
     }
     m_DecodeStack[m_StackLen++] = (uint8_t)data;
     code = data >> 16;
   }
   if (m_StackLen >= sizeof(m_DecodeStack)) {
     return;
   }
   m_DecodeStack[m_StackLen++] = (uint8_t)code;
 }
 int CLZWDecoder::Decode(uint8_t* dest_buf,
-                        FX_DWORD& dest_size,
+                        uint32_t& dest_size,
                         const uint8_t* src_buf,
-                        FX_DWORD& src_size,
+                        uint32_t& src_size,
                         FX_BOOL bEarlyChange) {
   m_CodeLen = 9;
   m_InPos = 0;
   m_OutPos = 0;
   m_pInput = src_buf;
   m_pOutput = dest_buf;
   m_Early = bEarlyChange ? 1 : 0;
   m_nCodes = 0;
-  FX_DWORD old_code = (FX_DWORD)-1;
+  uint32_t old_code = (uint32_t)-1;
   uint8_t last_char = 0;
   while (1) {
     if (m_InPos + m_CodeLen > src_size * 8) {
       break;
     }
     int byte_pos = m_InPos / 8;
     int bit_pos = m_InPos % 8, bit_left = m_CodeLen;
-    FX_DWORD code = 0;
+    uint32_t code = 0;
     if (bit_pos) {
       bit_left -= 8 - bit_pos;
       code = (m_pInput[byte_pos++] & ((1 << (8 - bit_pos)) - 1)) << bit_left;
     }
     if (bit_left < 8) {
       code |= m_pInput[byte_pos] >> (8 - bit_left);
     } else {
       bit_left -= 8;
       code |= m_pInput[byte_pos++] << bit_left;
       if (bit_left) {
         code |= m_pInput[byte_pos] >> (8 - bit_left);
       }
     }
     m_InPos += m_CodeLen;
     if (code < 256) {
       if (m_OutPos == dest_size) {
         return -5;
       }
       if (m_pOutput) {
         m_pOutput[m_OutPos] = (uint8_t)code;
       }
       m_OutPos++;
       last_char = (uint8_t)code;
-      if (old_code != (FX_DWORD)-1) {
+      if (old_code != (uint32_t)-1) {
         AddCode(old_code, last_char);
       }
       old_code = code;
     } else if (code == 256) {
       m_CodeLen = 9;
       m_nCodes = 0;
-      old_code = (FX_DWORD)-1;
+      old_code = (uint32_t)-1;
     } else if (code == 257) {
       break;
     } else {
-      if (old_code == (FX_DWORD)-1) {
+      if (old_code == (uint32_t)-1) {
         return 2;
       }
       m_StackLen = 0;
       if (code >= m_nCodes + 258) {
         if (m_StackLen < sizeof(m_DecodeStack)) {
           m_DecodeStack[m_StackLen++] = last_char;
         }
         DecodeString(old_code);
       } else {
         DecodeString(code);
       }
       if (m_OutPos + m_StackLen > dest_size) {
         return -5;
       }
       if (m_pOutput) {
-        for (FX_DWORD i = 0; i < m_StackLen; i++) {
+        for (uint32_t i = 0; i < m_StackLen; i++) {
           m_pOutput[m_OutPos + i] = m_DecodeStack[m_StackLen - i - 1];
         }
       }
       m_OutPos += m_StackLen;
       last_char = m_DecodeStack[m_StackLen - 1];
       if (old_code < 256) {
         AddCode(old_code, last_char);
       } else if (old_code - 258 >= m_nCodes) {
         dest_size = m_OutPos;
         src_size = (m_InPos + 7) / 8;
@@ skipping 17 matching lines @@
   if (pa <= pb && pa <= pc) {
     return (uint8_t)a;
   }
   if (pb <= pc) {
     return (uint8_t)b;
   }
   return (uint8_t)c;
 }
 
 FX_BOOL PNG_PredictorEncode(uint8_t*& data_buf,
-                            FX_DWORD& data_size,
+                            uint32_t& data_size,
                             int predictor,
                             int Colors,
                             int BitsPerComponent,
                             int Columns) {
   const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
   const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
   if (row_size <= 0)
     return FALSE;
   const int row_count = (data_size + row_size - 1) / row_size;
   const int last_row_size = data_size % row_size;
@@ skipping 136 matching lines @@
         break;
       }
       default:
         pDestData[byte] = raw_byte;
         break;
     }
   }
 }
 
 FX_BOOL PNG_Predictor(uint8_t*& data_buf,
-                      FX_DWORD& data_size,
+                      uint32_t& data_size,
                       int Colors,
                       int BitsPerComponent,
                       int Columns) {
   const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
   const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
   if (row_size <= 0)
     return FALSE;
   const int row_count = (data_size + row_size) / (row_size + 1);
   if (row_count <= 0)
     return FALSE;
@@ skipping 119 matching lines @@
       uint16_t pixel = (dest_buf[i] << 8) | dest_buf[i + 1];
       pixel -=
           (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1];
       dest_buf[i] = pixel >> 8;
       dest_buf[i + 1] = (uint8_t)pixel;
     }
   }
 }
 
 FX_BOOL TIFF_PredictorEncode(uint8_t*& data_buf,
-                             FX_DWORD& data_size,
+                             uint32_t& data_size,
                              int Colors,
                              int BitsPerComponent,
                              int Columns) {
   int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
   if (row_size == 0)
     return FALSE;
   const int row_count = (data_size + row_size - 1) / row_size;
   const int last_row_size = data_size % row_size;
   for (int row = 0; row < row_count; row++) {
     uint8_t* scan_line = data_buf + row * row_size;
     if ((row + 1) * row_size > (int)data_size) {
       row_size = last_row_size;
     }
     TIFF_PredictorEncodeLine(scan_line, row_size, BitsPerComponent, Colors,
                              Columns);
   }
   return TRUE;
 }
 
 void TIFF_PredictLine(uint8_t* dest_buf,
-                      FX_DWORD row_size,
+                      uint32_t row_size,
                       int BitsPerComponent,
                       int Colors,
                       int Columns) {
   if (BitsPerComponent == 1) {
     int row_bits = std::min(BitsPerComponent * Colors * Columns,
                             pdfium::base::checked_cast<int>(row_size * 8));
     int index_pre = 0;
     int col_pre = 0;
     for (int i = 1; i < row_bits; i++) {
       int col = i % 8;
       int index = i / 8;
       if (((dest_buf[index] >> (7 - col)) & 1) ^
           ((dest_buf[index_pre] >> (7 - col_pre)) & 1)) {
         dest_buf[index] |= 1 << (7 - col);
       } else {
         dest_buf[index] &= ~(1 << (7 - col));
       }
       index_pre = index;
       col_pre = col;
     }
     return;
   }
   int BytesPerPixel = BitsPerComponent * Colors / 8;
   if (BitsPerComponent == 16) {
-    for (FX_DWORD i = BytesPerPixel; i < row_size; i += 2) {
+    for (uint32_t i = BytesPerPixel; i < row_size; i += 2) {
       uint16_t pixel =
           (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1];
       pixel += (dest_buf[i] << 8) | dest_buf[i + 1];
       dest_buf[i] = pixel >> 8;
       dest_buf[i + 1] = (uint8_t)pixel;
     }
   } else {
-    for (FX_DWORD i = BytesPerPixel; i < row_size; i++) {
+    for (uint32_t i = BytesPerPixel; i < row_size; i++) {
       dest_buf[i] += dest_buf[i - BytesPerPixel];
     }
   }
 }
 
 FX_BOOL TIFF_Predictor(uint8_t*& data_buf,
-                       FX_DWORD& data_size,
+                       uint32_t& data_size,
                        int Colors,
                        int BitsPerComponent,
                        int Columns) {
   int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
   if (row_size == 0)
     return FALSE;
   const int row_count = (data_size + row_size - 1) / row_size;
   const int last_row_size = data_size % row_size;
   for (int row = 0; row < row_count; row++) {
     uint8_t* scan_line = data_buf + row * row_size;
     if ((row + 1) * row_size > (int)data_size) {
       row_size = last_row_size;
     }
     TIFF_PredictLine(scan_line, row_size, BitsPerComponent, Colors, Columns);
   }
   return TRUE;
 }
 
 void FlateUncompress(const uint8_t* src_buf,
-                     FX_DWORD src_size,
-                     FX_DWORD orig_size,
+                     uint32_t src_size,
+                     uint32_t orig_size,
                      uint8_t*& dest_buf,
-                     FX_DWORD& dest_size,
-                     FX_DWORD& offset) {
-  FX_DWORD guess_size = orig_size ? orig_size : src_size * 2;
-  const FX_DWORD kStepSize = 10240;
-  FX_DWORD alloc_step = orig_size ? kStepSize : std::min(src_size, kStepSize);
-  static const FX_DWORD kMaxInitialAllocSize = 10000000;
+                     uint32_t& dest_size,
+                     uint32_t& offset) {
+  uint32_t guess_size = orig_size ? orig_size : src_size * 2;
+  const uint32_t kStepSize = 10240;
+  uint32_t alloc_step = orig_size ? kStepSize : std::min(src_size, kStepSize);
+  static const uint32_t kMaxInitialAllocSize = 10000000;
   if (guess_size > kMaxInitialAllocSize) {
     guess_size = kMaxInitialAllocSize;
     alloc_step = kMaxInitialAllocSize;
   }
-  FX_DWORD buf_size = guess_size;
-  FX_DWORD last_buf_size = buf_size;
+  uint32_t buf_size = guess_size;
+  uint32_t last_buf_size = buf_size;
 
   dest_buf = nullptr;
   dest_size = 0;
   void* context = FPDFAPI_FlateInit(my_alloc_func, my_free_func);
   if (!context)
     return;
 
   std::unique_ptr<uint8_t, FxFreeDeleter> guess_buf(
       FX_Alloc(uint8_t, guess_size + 1));
   guess_buf.get()[guess_size] = '\0';
 
   FPDFAPI_FlateInput(context, src_buf, src_size);
 
   if (src_size < kStepSize) {
     // This is the old implementation.
     uint8_t* cur_buf = guess_buf.get();
     while (1) {
       int32_t ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size);
       if (ret != Z_OK)
         break;
       int32_t avail_buf_size = FPDFAPI_FlateGetAvailOut(context);
       if (avail_buf_size != 0)
         break;
 
-      FX_DWORD old_size = guess_size;
+      uint32_t old_size = guess_size;
       guess_size += alloc_step;
       if (guess_size < old_size || guess_size + 1 < guess_size) {
         FPDFAPI_FlateEnd(context);
         return;
       }
 
       {
         uint8_t* new_buf =
             FX_Realloc(uint8_t, guess_buf.release(), guess_size + 1);
         guess_buf.reset(new_buf);
@@ skipping 34 matching lines @@
       result_tmp_bufs.Add(cur_buf);
       cur_buf = FX_Alloc(uint8_t, buf_size + 1);
       cur_buf[buf_size] = '\0';
     }
     dest_size = FPDFAPI_FlateGetTotalOut(context);
     offset = FPDFAPI_FlateGetTotalIn(context);
     if (result_tmp_bufs.GetSize() == 1) {
       dest_buf = result_tmp_bufs[0];
     } else {
       uint8_t* result_buf = FX_Alloc(uint8_t, dest_size);
-      FX_DWORD result_pos = 0;
+      uint32_t result_pos = 0;
       for (int32_t i = 0; i < result_tmp_bufs.GetSize(); i++) {
         uint8_t* tmp_buf = result_tmp_bufs[i];
-        FX_DWORD tmp_buf_size = buf_size;
+        uint32_t tmp_buf_size = buf_size;
         if (i == result_tmp_bufs.GetSize() - 1) {
           tmp_buf_size = last_buf_size;
         }
         FXSYS_memcpy(result_buf + result_pos, tmp_buf, tmp_buf_size);
         result_pos += tmp_buf_size;
         FX_Free(result_tmp_bufs[i]);
       }
       dest_buf = result_buf;
     }
   }
   FPDFAPI_FlateEnd(context);
 }
 
 }  // namespace
 
 class CCodec_FlateScanlineDecoder : public CCodec_ScanlineDecoder {
  public:
   CCodec_FlateScanlineDecoder();
   ~CCodec_FlateScanlineDecoder() override;
 
   void Create(const uint8_t* src_buf,
-              FX_DWORD src_size,
+              uint32_t src_size,
               int width,
               int height,
               int nComps,
               int bpc,
               int predictor,
               int Colors,
               int BitsPerComponent,
               int Columns);
   void Destroy() { delete this; }
 
   // CCodec_ScanlineDecoder
   void v_DownScale(int dest_width, int dest_height) override {}
   FX_BOOL v_Rewind() override;
   uint8_t* v_GetNextLine() override;
-  FX_DWORD GetSrcOffset() override;
+  uint32_t GetSrcOffset() override;
 
   void* m_pFlate;
   const uint8_t* m_SrcBuf;
-  FX_DWORD m_SrcSize;
+  uint32_t m_SrcSize;
   uint8_t* m_pScanline;
   uint8_t* m_pLastLine;
   uint8_t* m_pPredictBuffer;
   uint8_t* m_pPredictRaw;
   int m_Predictor;
   int m_Colors;
   int m_BitsPerComponent;
   int m_Columns;
-  FX_DWORD m_PredictPitch;
+  uint32_t m_PredictPitch;
   size_t m_LeftOver;
 };
 
 CCodec_FlateScanlineDecoder::CCodec_FlateScanlineDecoder() {
   m_pFlate = NULL;
   m_pScanline = NULL;
   m_pLastLine = NULL;
   m_pPredictBuffer = NULL;
   m_pPredictRaw = NULL;
   m_LeftOver = 0;
 }
 CCodec_FlateScanlineDecoder::~CCodec_FlateScanlineDecoder() {
   FX_Free(m_pScanline);
   FX_Free(m_pLastLine);
   FX_Free(m_pPredictBuffer);
   FX_Free(m_pPredictRaw);
   if (m_pFlate) {
     FPDFAPI_FlateEnd(m_pFlate);
   }
 }
 void CCodec_FlateScanlineDecoder::Create(const uint8_t* src_buf,
-                                         FX_DWORD src_size,
+                                         uint32_t src_size,
                                          int width,
                                          int height,
                                          int nComps,
                                          int bpc,
                                          int predictor,
                                          int Colors,
                                          int BitsPerComponent,
                                          int Columns) {
   m_SrcBuf = src_buf;
   m_SrcSize = src_size;
   m_OutputWidth = m_OrigWidth = width;
   m_OutputHeight = m_OrigHeight = height;
   m_nComps = nComps;
   m_bpc = bpc;
   m_bColorTransformed = FALSE;
-  m_Pitch = (static_cast<FX_DWORD>(width) * nComps * bpc + 7) / 8;
+  m_Pitch = (static_cast<uint32_t>(width) * nComps * bpc + 7) / 8;
   m_pScanline = FX_Alloc(uint8_t, m_Pitch);
   m_Predictor = 0;
   if (predictor) {
     if (predictor >= 10) {
       m_Predictor = 2;
     } else if (predictor == 2) {
       m_Predictor = 1;
     }
     if (m_Predictor) {
       if (BitsPerComponent * Colors * Columns == 0) {
         BitsPerComponent = m_bpc;
         Colors = m_nComps;
         Columns = m_OrigWidth;
       }
       m_Colors = Colors;
       m_BitsPerComponent = BitsPerComponent;
       m_Columns = Columns;
       m_PredictPitch =
-          (static_cast<FX_DWORD>(m_BitsPerComponent) * m_Colors * m_Columns +
+          (static_cast<uint32_t>(m_BitsPerComponent) * m_Colors * m_Columns +
            7) /
           8;
       m_pLastLine = FX_Alloc(uint8_t, m_PredictPitch);
       m_pPredictRaw = FX_Alloc(uint8_t, m_PredictPitch + 1);
       m_pPredictBuffer = FX_Alloc(uint8_t, m_PredictPitch);
     }
   }
 }
 FX_BOOL CCodec_FlateScanlineDecoder::v_Rewind() {
   if (m_pFlate) {
@@ skipping 48 matching lines @@
                      read_bytes);
         m_LeftOver += m_PredictPitch - read_bytes;
         bytes_to_go -= read_bytes;
       }
     }
   } else {
     FPDFAPI_FlateOutput(m_pFlate, m_pScanline, m_Pitch);
   }
   return m_pScanline;
 }
-FX_DWORD CCodec_FlateScanlineDecoder::GetSrcOffset() {
+uint32_t CCodec_FlateScanlineDecoder::GetSrcOffset() {
   return FPDFAPI_FlateGetTotalIn(m_pFlate);
 }
 
 ICodec_ScanlineDecoder* CCodec_FlateModule::CreateDecoder(
     const uint8_t* src_buf,
-    FX_DWORD src_size,
+    uint32_t src_size,
     int width,
     int height,
     int nComps,
     int bpc,
     int predictor,
     int Colors,
     int BitsPerComponent,
     int Columns) {
   CCodec_FlateScanlineDecoder* pDecoder = new CCodec_FlateScanlineDecoder;
   pDecoder->Create(src_buf, src_size, width, height, nComps, bpc, predictor,
                    Colors, BitsPerComponent, Columns);
   return pDecoder;
 }
-FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW,
+uint32_t CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW,
                                               const uint8_t* src_buf,
-                                              FX_DWORD src_size,
+                                              uint32_t src_size,
                                               FX_BOOL bEarlyChange,
                                               int predictor,
                                               int Colors,
                                               int BitsPerComponent,
                                               int Columns,
-                                              FX_DWORD estimated_size,
+                                              uint32_t estimated_size,
                                               uint8_t*& dest_buf,
-                                              FX_DWORD& dest_size) {
+                                              uint32_t& dest_size) {
   dest_buf = NULL;
-  FX_DWORD offset = 0;
+  uint32_t offset = 0;
   int predictor_type = 0;
   if (predictor) {
     if (predictor >= 10) {
       predictor_type = 2;
     } else if (predictor == 2) {
       predictor_type = 1;
     }
   }
   if (bLZW) {
     {
       std::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder);
-      dest_size = (FX_DWORD)-1;
+      dest_size = (uint32_t)-1;
       offset = src_size;
       int err = decoder->Decode(NULL, dest_size, src_buf, offset, bEarlyChange);
       if (err || dest_size == 0 || dest_size + 1 < dest_size) {
-        return static_cast<FX_DWORD>(-1);
+        return static_cast<uint32_t>(-1);
       }
     }
     {
       std::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder);
       dest_buf = FX_Alloc(uint8_t, dest_size + 1);
       dest_buf[dest_size] = '\0';
       decoder->Decode(dest_buf, dest_size, src_buf, offset, bEarlyChange);
     }
   } else {
     FlateUncompress(src_buf, src_size, estimated_size, dest_buf, dest_size,
                     offset);
   }
   if (predictor_type == 0) {
     return offset;
   }
   FX_BOOL ret = TRUE;
   if (predictor_type == 2) {
     ret = PNG_Predictor(dest_buf, dest_size, Colors, BitsPerComponent, Columns);
   } else if (predictor_type == 1) {
     ret =
         TIFF_Predictor(dest_buf, dest_size, Colors, BitsPerComponent, Columns);
   }
-  return ret ? offset : static_cast<FX_DWORD>(-1);
+  return ret ? offset : static_cast<uint32_t>(-1);
 }
 FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf,
-                                   FX_DWORD src_size,
+                                   uint32_t src_size,
                                    int predictor,
                                    int Colors,
                                    int BitsPerComponent,
                                    int Columns,
                                    uint8_t*& dest_buf,
-                                   FX_DWORD& dest_size) {
+                                   uint32_t& dest_size) {
   if (predictor != 2 && predictor < 10) {
     return Encode(src_buf, src_size, dest_buf, dest_size);
   }
   uint8_t* pSrcBuf = NULL;
   pSrcBuf = FX_Alloc(uint8_t, src_size);
   FXSYS_memcpy(pSrcBuf, src_buf, src_size);
   FX_BOOL ret = TRUE;
   if (predictor == 2) {
     ret = TIFF_PredictorEncode(pSrcBuf, src_size, Colors, BitsPerComponent,
                                Columns);
   } else if (predictor >= 10) {
     ret = PNG_PredictorEncode(pSrcBuf, src_size, predictor, Colors,
                               BitsPerComponent, Columns);
   }
   if (ret)
     ret = Encode(pSrcBuf, src_size, dest_buf, dest_size);
   FX_Free(pSrcBuf);
   return ret;
 }
 FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf,
-                                   FX_DWORD src_size,
+                                   uint32_t src_size,
                                    uint8_t*& dest_buf,
-                                   FX_DWORD& dest_size) {
+                                   uint32_t& dest_size) {
   dest_size = src_size + src_size / 1000 + 12;
   dest_buf = FX_Alloc(uint8_t, dest_size);
   unsigned long temp_size = dest_size;
   FPDFAPI_FlateCompress(dest_buf, &temp_size, src_buf, src_size);
-  dest_size = (FX_DWORD)temp_size;
+  dest_size = (uint32_t)temp_size;
   return TRUE;
 }