Remove FX_WORD in favor of uint16_t.

core/fxcodec/lgif/fx_gif.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/lgif/fx_gif.h"
 
 #include "core/fxcodec/lbmp/fx_bmp.h"
 
@@ skipping 12 matching lines @@
   code_store = 0;
   next_in = NULL;
   avail_in = 0;
   stack_size = 0;
   code_first = 0;
   ClearTable();
 }
 void CGifLZWDecoder::ClearTable() {
   code_size_cur = code_size + 1;
   code_next = code_end + 1;
-  code_old = (FX_WORD)-1;
+  code_old = (uint16_t)-1;
   FXSYS_memset(code_table, 0, sizeof(tag_Table) * GIF_MAX_LZW_CODE);
   FXSYS_memset(stack, 0, GIF_MAX_LZW_CODE);
-  for (FX_WORD i = 0; i < code_clear; i++) {
+  for (uint16_t i = 0; i < code_clear; i++) {
     code_table[i].suffix = (uint8_t)i;
   }
 }
-void CGifLZWDecoder::DecodeString(FX_WORD code) {
+void CGifLZWDecoder::DecodeString(uint16_t code) {
   stack_size = 0;
   while (TRUE) {
     ASSERT(code <= code_next);
     if (code < code_clear || code > code_next) {
       break;
     }
     stack[GIF_MAX_LZW_CODE - 1 - stack_size++] = code_table[code].suffix;
     code = code_table[code].prefix;
   }
   stack[GIF_MAX_LZW_CODE - 1 - stack_size++] = (uint8_t)code;
   code_first = (uint8_t)code;
 }
-void CGifLZWDecoder::AddCode(FX_WORD prefix_code, uint8_t append_char) {
+void CGifLZWDecoder::AddCode(uint16_t prefix_code, uint8_t append_char) {
   if (code_next == GIF_MAX_LZW_CODE) {
     return;
   }
   code_table[code_next].prefix = prefix_code;
   code_table[code_next].suffix = append_char;
   if (++code_next < GIF_MAX_LZW_CODE) {
     if (code_next >> code_size_cur) {
       code_size_cur++;
     }
   }
 }
 int32_t CGifLZWDecoder::Decode(uint8_t* des_buf, FX_DWORD& des_size) {
   if (des_size == 0) {
     return 3;
   }
   FX_DWORD i = 0;
   if (stack_size != 0) {
     if (des_size < stack_size) {
       FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], des_size);
-      stack_size -= (FX_WORD)des_size;
+      stack_size -= (uint16_t)des_size;
       return 3;
     }
     FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], stack_size);
     des_buf += stack_size;
     i += stack_size;
     stack_size = 0;
   }
-  FX_WORD code = 0;
+  uint16_t code = 0;
   while (i <= des_size && (avail_in > 0 || bits_left >= code_size_cur)) {
     if (code_size_cur > 12) {
       if (err_msg_ptr) {
         FXSYS_strncpy(err_msg_ptr, "Code Length Out Of Range",
                       GIF_MAX_ERROR_SIZE - 1);
       }
       return 0;
     }
     if (avail_in > 0) {
       code_store |= (*next_in++) << bits_left;
       avail_in--;
       bits_left += 8;
     }
     while (bits_left >= code_size_cur) {
-      code = (FX_WORD)code_store & ((1 << code_size_cur) - 1);
+      code = (uint16_t)code_store & ((1 << code_size_cur) - 1);
       code_store >>= code_size_cur;
       bits_left -= code_size_cur;
       if (code == code_clear) {
         ClearTable();
         continue;
       } else if (code == code_end) {
         des_size = i;
         return 1;
       } else {
-        if (code_old != (FX_WORD)-1) {
+        if (code_old != (uint16_t)-1) {
           if (code_next < GIF_MAX_LZW_CODE) {
             if (code == code_next) {
               AddCode(code_old, code_first);
               DecodeString(code);
             } else if (code > code_next) {
               if (err_msg_ptr) {
                 FXSYS_strncpy(err_msg_ptr, "Decode Error, Out Of Range",
                               GIF_MAX_ERROR_SIZE - 1);
               }
               return 0;
             } else {
               DecodeString(code);
               uint8_t append_char = stack[GIF_MAX_LZW_CODE - stack_size];
               AddCode(code_old, append_char);
             }
           }
         } else {
           DecodeString(code);
         }
         code_old = code;
         if (i + stack_size > des_size) {
           FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size],
                        des_size - i);
-          stack_size -= (FX_WORD)(des_size - i);
+          stack_size -= (uint16_t)(des_size - i);
           return 3;
         }
         FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size],
                      stack_size);
         des_buf += stack_size;
         i += stack_size;
         stack_size = 0;
       }
     }
   }
@@ skipping 31 matching lines @@
                                  uint8_t bit_use) {
   FX_DWORD cut = ((1 << (index_bit - index_bit_use)) - 1) << index_bit_use;
   val |= ((index & cut) >> index_bit_use) << bit_use;
 }
 static inline uint8_t gif_cut_buf(const uint8_t* buf,
                                   FX_DWORD& offset,
                                   uint8_t bit_cut,
                                   uint8_t& bit_offset,
                                   FX_DWORD& bit_num) {
   if (bit_cut != 8) {
-    FX_WORD index = 0;
+    uint16_t index = 0;
     index |= ((1 << bit_cut) - 1) << (7 - bit_offset);
     uint8_t ret = ((index & buf[offset]) >> (7 - bit_offset));
     bit_offset += bit_cut;
     if (bit_offset >= 8) {
       if (bit_offset > 8) {
         ret |= ((index & (buf[offset + 1] << 8)) >> 8);
       }
       bit_offset -= 8;
       offset++;
     }
     bit_num += bit_cut;
     return ret;
   }
   bit_num += bit_cut;
   return buf[offset++];
 }
 CGifLZWEncoder::CGifLZWEncoder() {
   FXSYS_memset(this, 0, sizeof(CGifLZWEncoder));
 }
 CGifLZWEncoder::~CGifLZWEncoder() {}
 void CGifLZWEncoder::ClearTable() {
   index_bit_cur = code_size + 1;
   index_num = code_end + 1;
   table_cur = code_end + 1;
-  for (FX_WORD i = 0; i < GIF_MAX_LZW_CODE; i++) {
+  for (uint16_t i = 0; i < GIF_MAX_LZW_CODE; i++) {
     code_table[i].prefix = 0;
     code_table[i].suffix = 0;
   }
 }
 void CGifLZWEncoder::Start(uint8_t code_len,
                            const uint8_t* src_buf,
                            uint8_t*& dst_buf,
                            FX_DWORD& offset) {
   code_size = code_len + 1;
   src_bit_cut = code_size;
@@ skipping 110 matching lines @@
     }
   }
   src_offset = 0;
   src_bit_offset = 0;
   src_bit_num = 0;
   return TRUE;
 }
 FX_BOOL CGifLZWEncoder::LookUpInTable(const uint8_t* buf,
                                       FX_DWORD& offset,
                                       uint8_t& bit_offset) {
-  for (FX_WORD i = table_cur; i < index_num; i++) {
+  for (uint16_t i = table_cur; i < index_num; i++) {
     if (code_table[i].prefix == code_table[index_num].prefix &&
         code_table[i].suffix == code_table[index_num].suffix) {
       code_table[index_num].prefix = i;
       code_table[index_num].suffix =
           gif_cut_buf(buf, offset, src_bit_cut, bit_offset, src_bit_num);
       table_cur = i;
       return TRUE;
     }
   }
   table_cur = code_end + 1;
@@ skipping 685 matching lines @@
   FXSYS_memcpy(dst_buf, gif_ptr->header_ptr, sizeof(GifHeader));
   gif_ptr->cur_offset += sizeof(GifHeader);
   SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->lsd_ptr->width);
   gif_ptr->cur_offset += 2;
   SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->lsd_ptr->height);
   gif_ptr->cur_offset += 2;
   dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->global_flag;
   dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->bc_index;
   dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->pixel_aspect;
   if (gif_ptr->global_pal) {
-    FX_WORD size = sizeof(GifPalette) * gif_ptr->gpal_num;
+    uint16_t size = sizeof(GifPalette) * gif_ptr->gpal_num;
     if (!gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + size)) {
       return FALSE;
     }
     FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->global_pal, size);
     gif_ptr->cur_offset += size;
   }
   return TRUE;
 }
 void interlace_buf(const uint8_t* buf, FX_DWORD pitch, FX_DWORD height) {
   CFX_ArrayTemplate<uint8_t*> pass[4];
@@ skipping 165 matching lines @@
     gif_ptr->cur_offset = cur_offset;
     res = FALSE;
   }
   dst_len = gif_ptr->cur_offset;
   dst_buf[dst_len - 1] = GIF_SIG_TRAILER;
   if (res) {
     gif_ptr->frames++;
   }
   return res;
 }