Remove FX_BOOL from core

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 40 matching lines @@
   code_next = code_end + 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 (uint16_t i = 0; i < code_clear; i++) {
     code_table[i].suffix = (uint8_t)i;
   }
 }
 void CGifLZWDecoder::DecodeString(uint16_t code) {
   stack_size = 0;
-  while (TRUE) {
+  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;
 }
@@ skipping 84 matching lines @@
         stack_size = 0;
       }
     }
   }
   if (avail_in == 0) {
     des_size = i;
     return 2;
   }
   return 0;
 }
-static FX_BOOL gif_grow_buf(uint8_t*& dst_buf,
-                            uint32_t& dst_len,
-                            uint32_t size) {
+static bool gif_grow_buf(uint8_t*& dst_buf, uint32_t& dst_len, uint32_t size) {
   if (dst_len < size) {
     uint32_t len_org = dst_len;
     while (dst_buf && dst_len < size) {
       dst_len <<= 1;
       // TODO(thestig): Probably should be a try-realloc here.
       dst_buf = FX_Realloc(uint8_t, dst_buf, dst_len);
     }
     if (!dst_buf) {
       dst_len = size;
       dst_buf = FX_Realloc(uint8_t, dst_buf, dst_len);
     }
     FXSYS_memset(dst_buf + len_org, 0, dst_len - len_org);
     return !!dst_buf;
   }
-  return TRUE;
+  return true;
 }
 static inline void gif_cut_index(uint8_t& val,
                                  uint32_t index,
                                  uint8_t index_bit,
                                  uint8_t index_bit_use,
                                  uint8_t bit_use) {
   uint32_t 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,
@@ skipping 117 matching lines @@
     }
   }
   if (index == code_end) {
     index_buf_len++;
     WriteBlock(dst_buf, dst_len, offset);
   }
   if (index_num++ >> index_bit_cur) {
     index_bit_cur++;
   }
 }
-FX_BOOL CGifLZWEncoder::Encode(const uint8_t* src_buf,
-                               uint32_t src_len,
-                               uint8_t*& dst_buf,
-                               uint32_t& dst_len,
-                               uint32_t& offset) {
+bool CGifLZWEncoder::Encode(const uint8_t* src_buf,
+                            uint32_t src_len,
+                            uint8_t*& dst_buf,
+                            uint32_t& dst_len,
+                            uint32_t& offset) {
   uint8_t suffix;
   if (setjmp(jmp)) {
-    return FALSE;
+    return false;
   }
   while (src_bit_num < src_len) {
     if (!LookUpInTable(src_buf, src_offset, src_bit_offset)) {
       EncodeString(code_table[index_num].prefix, dst_buf, dst_len, offset);
       if (index_num == GIF_MAX_LZW_CODE) {
         suffix = code_table[index_num - 1].suffix;
         EncodeString(code_clear, dst_buf, dst_len, offset);
         ClearTable();
         code_table[index_num].prefix = suffix;
         code_table[index_num].suffix = gif_cut_buf(
             src_buf, src_offset, src_bit_cut, src_bit_offset, src_bit_num);
       } else {
         code_table[index_num].prefix = code_table[index_num - 1].suffix;
         code_table[index_num].suffix = gif_cut_buf(
             src_buf, src_offset, src_bit_cut, src_bit_offset, src_bit_num);
       }
     }
   }
   src_offset = 0;
   src_bit_offset = 0;
   src_bit_num = 0;
-  return TRUE;
+  return true;
 }
-FX_BOOL CGifLZWEncoder::LookUpInTable(const uint8_t* buf,
-                                      uint32_t& offset,
-                                      uint8_t& out_bit_offset) {
+bool CGifLZWEncoder::LookUpInTable(const uint8_t* buf,
+                                   uint32_t& offset,
+                                   uint8_t& out_bit_offset) {
   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, out_bit_offset, src_bit_num);
       table_cur = i;
-      return TRUE;
+      return true;
     }
   }
   table_cur = code_end + 1;
-  return FALSE;
+  return false;
 }
 void CGifLZWEncoder::Finish(uint8_t*& dst_buf,
                             uint32_t& dst_len,
                             uint32_t& offset) {
   EncodeString(code_table[index_num].prefix, dst_buf, dst_len, offset);
   EncodeString(code_end, dst_buf, dst_len, offset);
   bit_offset = 0;
   ClearTable();
 }
 gif_decompress_struct_p gif_create_decompress() {
@@ skipping 170 matching lines @@
   gif_ptr->height = (int)GetWord_LSBFirst((uint8_t*)&gif_lsd_ptr->height);
   gif_ptr->bc_index = gif_lsd_ptr->bc_index;
   gif_ptr->pixel_aspect = gif_lsd_ptr->pixel_aspect;
   return 1;
 }
 int32_t gif_get_frame(gif_decompress_struct_p gif_ptr) {
   if (!gif_ptr)
     return 0;
 
   int32_t ret = 1;
-  while (TRUE) {
+  while (true) {
     switch (gif_ptr->decode_status) {
       case GIF_D_STATUS_TAIL:
         return 1;
       case GIF_D_STATUS_SIG: {
         uint8_t* sig_ptr = nullptr;
         if (!gif_read_data(gif_ptr, &sig_ptr, 1))
           return 2;
 
         switch (*sig_ptr) {
           case GIF_SIG_EXTENSION:
@@ skipping 284 matching lines @@
     }
     gif_image_ptr->image_row_buf = FX_Alloc(uint8_t, gif_img_row_bytes);
     GifGCE* gif_img_gce_ptr = gif_image_ptr->image_gce_ptr;
     int32_t loc_pal_num =
         ((GifLF*)&gif_image_ptr->image_info_ptr->local_flag)->local_pal
             ? (2 << ((GifLF*)&gif_image_ptr->image_info_ptr->local_flag)
                         ->pal_bits)
             : 0;
     gif_ptr->avail_in = 0;
     if (!gif_img_gce_ptr) {
-      FX_BOOL bRes = gif_ptr->gif_get_record_position_fn(
+      bool bRes = gif_ptr->gif_get_record_position_fn(
           gif_ptr, gif_image_ptr->image_data_pos,
           gif_image_ptr->image_info_ptr->left,
           gif_image_ptr->image_info_ptr->top,
           gif_image_ptr->image_info_ptr->width,
           gif_image_ptr->image_info_ptr->height, loc_pal_num,
           gif_image_ptr->local_pal_ptr, 0, 0, -1, 0,
-          (FX_BOOL)((GifLF*)&gif_image_ptr->image_info_ptr->local_flag)
+          (bool)((GifLF*)&gif_image_ptr->image_info_ptr->local_flag)
               ->interlace);
       if (!bRes) {
         FX_Free(gif_image_ptr->image_row_buf);
         gif_image_ptr->image_row_buf = nullptr;
         gif_error(gif_ptr, "Error Read Record Position Data");
         return 0;
       }
     } else {
-      FX_BOOL bRes = gif_ptr->gif_get_record_position_fn(
+      bool bRes = gif_ptr->gif_get_record_position_fn(
           gif_ptr, gif_image_ptr->image_data_pos,
           gif_image_ptr->image_info_ptr->left,
           gif_image_ptr->image_info_ptr->top,
           gif_image_ptr->image_info_ptr->width,
           gif_image_ptr->image_info_ptr->height, loc_pal_num,
           gif_image_ptr->local_pal_ptr,
           (int32_t)gif_image_ptr->image_gce_ptr->delay_time,
-          (FX_BOOL)((GifCEF*)&gif_image_ptr->image_gce_ptr->gce_flag)
-              ->user_input,
+          (bool)((GifCEF*)&gif_image_ptr->image_gce_ptr->gce_flag)->user_input,
           ((GifCEF*)&gif_image_ptr->image_gce_ptr->gce_flag)->transparency
               ? (int32_t)gif_image_ptr->image_gce_ptr->trans_index
               : -1,
           (int32_t)((GifCEF*)&gif_image_ptr->image_gce_ptr->gce_flag)
               ->disposal_method,
-          (FX_BOOL)((GifLF*)&gif_image_ptr->image_info_ptr->local_flag)
+          (bool)((GifLF*)&gif_image_ptr->image_info_ptr->local_flag)
               ->interlace);
       if (!bRes) {
         FX_Free(gif_image_ptr->image_row_buf);
         gif_image_ptr->image_row_buf = nullptr;
         gif_error(gif_ptr, "Error Read Record Position Data");
         return 0;
       }
     }
     if (!gif_ptr->img_decoder_ptr)
       gif_ptr->img_decoder_ptr = new CGifLZWDecoder(gif_ptr->err_ptr);
@@ skipping 128 matching lines @@
     *avail_buf_ptr = nullptr;
     if (gif_ptr->avail_in > 0) {
       *avail_buf_ptr = gif_ptr->next_in;
     }
   }
   return gif_ptr->avail_in;
 }
 int32_t gif_get_frame_num(gif_decompress_struct_p gif_ptr) {
   return gif_ptr->img_ptr_arr_ptr->GetSize();
 }
-static FX_BOOL gif_write_header(gif_compress_struct_p gif_ptr,
-                                uint8_t*& dst_buf,
-                                uint32_t& dst_len) {
+static bool gif_write_header(gif_compress_struct_p gif_ptr,
+                             uint8_t*& dst_buf,
+                             uint32_t& dst_len) {
   if (gif_ptr->cur_offset) {
-    return TRUE;
+    return true;
   }
   dst_len = sizeof(GifHeader) + sizeof(GifLSD) + sizeof(GifGF);
   dst_buf = FX_TryAlloc(uint8_t, dst_len);
   if (!dst_buf)
-    return FALSE;
+    return false;
 
   FXSYS_memset(dst_buf, 0, dst_len);
   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) {
     uint16_t size = sizeof(GifPalette) * gif_ptr->gpal_num;
     if (!gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + size)) {
-      return FALSE;
+      return false;
     }
     FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->global_pal, size);
     gif_ptr->cur_offset += size;
   }
-  return TRUE;
+  return true;
 }
 void interlace_buf(const uint8_t* buf, uint32_t pitch, uint32_t height) {
   CFX_ArrayTemplate<uint8_t*> pass[4];
   int i, j;
   uint32_t row;
   row = 0;
   uint8_t* temp;
   while (row < height) {
     if (row % 8 == 0) {
       j = 0;
@@ skipping 26 matching lines @@
     dst_buf[dst_offset++] = GIF_DATA_BLOCK;
     FXSYS_memcpy(&dst_buf[dst_offset], &src_buf[src_offset], GIF_DATA_BLOCK);
     dst_offset += GIF_DATA_BLOCK;
     src_offset += GIF_DATA_BLOCK;
     src_len -= GIF_DATA_BLOCK;
   }
   dst_buf[dst_offset++] = (uint8_t)src_len;
   FXSYS_memcpy(&dst_buf[dst_offset], &src_buf[src_offset], src_len);
   dst_offset += src_len;
 }
-static FX_BOOL gif_write_data(gif_compress_struct_p gif_ptr,
-                              uint8_t*& dst_buf,
-                              uint32_t& dst_len) {
+static bool gif_write_data(gif_compress_struct_p gif_ptr,
+                           uint8_t*& dst_buf,
+                           uint32_t& dst_len) {
   if (!gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + GIF_DATA_BLOCK)) {
-    return FALSE;
+    return false;
   }
   if (FXSYS_memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0) {
     dst_buf[gif_ptr->cur_offset++] = GIF_SIG_EXTENSION;
     dst_buf[gif_ptr->cur_offset++] = GIF_BLOCK_GCE;
     gif_ptr->gce_ptr->block_size = 4;
     dst_buf[gif_ptr->cur_offset++] = gif_ptr->gce_ptr->block_size;
     gif_ptr->gce_ptr->gce_flag = 0;
     dst_buf[gif_ptr->cur_offset++] = gif_ptr->gce_ptr->gce_flag;
     gif_ptr->gce_ptr->delay_time = 10;
     SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
@@ skipping 13 matching lines @@
                    gif_ptr->image_info_ptr->width);
   gif_ptr->cur_offset += 2;
   SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
                    gif_ptr->image_info_ptr->height);
   gif_ptr->cur_offset += 2;
   GifLF& lf = (GifLF&)gif_ptr->image_info_ptr->local_flag;
   dst_buf[gif_ptr->cur_offset++] = gif_ptr->image_info_ptr->local_flag;
   if (gif_ptr->local_pal) {
     uint32_t pal_size = sizeof(GifPalette) * gif_ptr->lpal_num;
     if (!gif_grow_buf(dst_buf, dst_len, pal_size + gif_ptr->cur_offset)) {
-      return FALSE;
+      return false;
     }
     FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->local_pal, pal_size);
     gif_ptr->cur_offset += pal_size;
   }
   if (lf.interlace) {
     interlace_buf(gif_ptr->src_buf, gif_ptr->src_pitch,
                   gif_ptr->image_info_ptr->height);
   }
   uint8_t code_bit = lf.pal_bits;
   if (lf.local_pal == 0) {
     GifGF& gf = (GifGF&)gif_ptr->lsd_ptr->global_flag;
     code_bit = gf.pal_bits;
   }
   gif_ptr->img_encoder_ptr->Start(code_bit, gif_ptr->src_buf, dst_buf,
                                   gif_ptr->cur_offset);
   uint32_t i;
   for (i = 0; i < gif_ptr->src_row; i++) {
     if (!gif_ptr->img_encoder_ptr->Encode(
             &gif_ptr->src_buf[i * gif_ptr->src_pitch],
             gif_ptr->src_width * (code_bit + 1), dst_buf, dst_len,
             gif_ptr->cur_offset)) {
-      return FALSE;
+      return false;
     }
   }
   gif_ptr->img_encoder_ptr->Finish(dst_buf, dst_len, gif_ptr->cur_offset);
   dst_buf[gif_ptr->cur_offset++] = 0;
   if (FXSYS_memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0 &&
       gif_ptr->cmt_data_ptr) {
     dst_buf[gif_ptr->cur_offset++] = GIF_SIG_EXTENSION;
     dst_buf[gif_ptr->cur_offset++] = GIF_BLOCK_CE;
     gif_write_block_data(gif_ptr->cmt_data_ptr, gif_ptr->cmt_data_len, dst_buf,
                          dst_len, gif_ptr->cur_offset);
@@ skipping 24 matching lines @@
     SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->pte_ptr->fc_index);
     gif_ptr->cur_offset += 2;
     SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->pte_ptr->bc_index);
     gif_ptr->cur_offset += 2;
     gif_write_block_data(gif_ptr->pte_data_ptr, gif_ptr->pte_data_len, dst_buf,
                          dst_len, gif_ptr->cur_offset);
     gif_ptr->cur_offset += gif_ptr->pte_data_len;
     dst_buf[gif_ptr->cur_offset++] = 0;
   }
   dst_buf[gif_ptr->cur_offset++] = GIF_SIG_TRAILER;
-  return TRUE;
+  return true;
 }
-FX_BOOL gif_encode(gif_compress_struct_p gif_ptr,
-                   uint8_t*& dst_buf,
-                   uint32_t& dst_len) {
+bool gif_encode(gif_compress_struct_p gif_ptr,
+                uint8_t*& dst_buf,
+                uint32_t& dst_len) {
   if (!gif_write_header(gif_ptr, dst_buf, dst_len)) {
-    return FALSE;
+    return false;
   }
   uint32_t cur_offset = gif_ptr->cur_offset;
-  FX_BOOL res = TRUE;
+  bool res = true;
   if (gif_ptr->frames) {
     gif_ptr->cur_offset--;
   }
   if (!gif_write_data(gif_ptr, dst_buf, dst_len)) {
     gif_ptr->cur_offset = cur_offset;
-    res = FALSE;
+    res = false;
   }
   dst_len = gif_ptr->cur_offset;
   dst_buf[dst_len - 1] = GIF_SIG_TRAILER;
   if (res) {
     gif_ptr->frames++;
   }
   return res;
 }