Get rid of NULLs in 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"
 
 void CGifLZWDecoder::Input(uint8_t* src_buf, uint32_t src_size) {
   next_in = src_buf;
   avail_in = src_size;
 }
 uint32_t CGifLZWDecoder::GetAvailInput() {
   return avail_in;
 }
 void CGifLZWDecoder::InitTable(uint8_t code_len) {
   code_size = code_len;
   code_clear = 1 << code_size;
   code_end = code_clear + 1;
   bits_left = 0;
   code_store = 0;
-  next_in = NULL;
+  next_in = nullptr;
   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 = (uint16_t)-1;
   FXSYS_memset(code_table, 0, sizeof(tag_Table) * GIF_MAX_LZW_CODE);
@@ skipping 111 matching lines @@
 }
 static FX_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;
       dst_buf = FX_Realloc(uint8_t, dst_buf, dst_len);
     }
-    if (dst_buf == NULL) {
+    if (!dst_buf) {
       dst_len = size;
       dst_buf = FX_Realloc(uint8_t, dst_buf, dst_len);
-      if (dst_buf == NULL) {
-        return FALSE;
-      }
     }
     FXSYS_memset(dst_buf + len_org, 0, dst_len - len_org);
-    return dst_buf != NULL;
+    return !!dst_buf;
   }
   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;
@@ skipping 177 matching lines @@
                             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() {
   gif_decompress_struct_p gif_ptr =
       (gif_decompress_struct*)FX_Alloc(uint8_t, sizeof(gif_decompress_struct));
-  if (gif_ptr == NULL) {
-    return NULL;
-  }
+  if (!gif_ptr)
+    return nullptr;
+
   FXSYS_memset(gif_ptr, 0, sizeof(gif_decompress_struct));
   gif_ptr->decode_status = GIF_D_STATUS_SIG;
   gif_ptr->img_ptr_arr_ptr = new CFX_ArrayTemplate<GifImage*>;
   gif_ptr->cmt_data_ptr = new CFX_ByteString;
   gif_ptr->pt_ptr_arr_ptr = new CFX_ArrayTemplate<GifPlainText*>;
   return gif_ptr;
 }
 void gif_destroy_decompress(gif_decompress_struct_pp gif_ptr_ptr) {
-  if (gif_ptr_ptr == NULL || *gif_ptr_ptr == NULL) {
+  if (!gif_ptr_ptr || !*gif_ptr_ptr)
     return;
-  }
+
   gif_decompress_struct_p gif_ptr = *gif_ptr_ptr;
-  *gif_ptr_ptr = NULL;
+  *gif_ptr_ptr = nullptr;
   FX_Free(gif_ptr->global_pal_ptr);
   delete gif_ptr->img_decoder_ptr;
   if (gif_ptr->img_ptr_arr_ptr) {
     int32_t size_img_arr = gif_ptr->img_ptr_arr_ptr->GetSize();
     for (int32_t i = 0; i < size_img_arr; i++) {
       GifImage* p = gif_ptr->img_ptr_arr_ptr->GetAt(i);
       FX_Free(p->image_info_ptr);
       FX_Free(p->image_gce_ptr);
       FX_Free(p->image_row_buf);
       if (p->local_pal_ptr && p->local_pal_ptr != gif_ptr->global_pal_ptr) {
@@ skipping 15 matching lines @@
       delete p->string_ptr;
     }
     gif_ptr->pt_ptr_arr_ptr->RemoveAll();
     delete gif_ptr->pt_ptr_arr_ptr;
   }
   FX_Free(gif_ptr);
 }
 gif_compress_struct_p gif_create_compress() {
   gif_compress_struct_p gif_ptr =
       (gif_compress_struct*)FX_Alloc(uint8_t, sizeof(gif_compress_struct));
-  if (gif_ptr == NULL) {
-    return NULL;
-  }
+  if (!gif_ptr)
+    return nullptr;
+
   FXSYS_memset(gif_ptr, 0, sizeof(gif_compress_struct));
   gif_ptr->img_encoder_ptr = new CGifLZWEncoder;
   gif_ptr->header_ptr = (GifHeader*)FX_Alloc(uint8_t, sizeof(GifHeader));
-  if (gif_ptr->header_ptr == NULL) {
+  if (!gif_ptr->header_ptr) {
     delete (gif_ptr->img_encoder_ptr);
     FX_Free(gif_ptr);
-    return NULL;
+    return nullptr;
   }
   FXSYS_memcpy(gif_ptr->header_ptr->signature, GIF_SIGNATURE, 3);
   FXSYS_memcpy(gif_ptr->header_ptr->version, "89a", 3);
   gif_ptr->lsd_ptr = (GifLSD*)FX_Alloc(uint8_t, sizeof(GifLSD));
-  if (gif_ptr->lsd_ptr == NULL) {
+  if (!gif_ptr->lsd_ptr) {
     FX_Free(gif_ptr->header_ptr);
     delete (gif_ptr->img_encoder_ptr);
     FX_Free(gif_ptr);
-    return NULL;
+    return nullptr;
   }
   FXSYS_memset(gif_ptr->lsd_ptr, 0, sizeof(GifLSD));
   gif_ptr->image_info_ptr =
       (GifImageInfo*)FX_Alloc(uint8_t, sizeof(GifImageInfo));
-  if (gif_ptr->image_info_ptr == NULL) {
+  if (!gif_ptr->image_info_ptr) {
     FX_Free(gif_ptr->lsd_ptr);
     FX_Free(gif_ptr->header_ptr);
     delete (gif_ptr->img_encoder_ptr);
     FX_Free(gif_ptr);
-    return NULL;
+    return nullptr;
   }
   FXSYS_memset(gif_ptr->image_info_ptr, 0, sizeof(GifImageInfo));
   gif_ptr->gce_ptr = (GifGCE*)FX_Alloc(uint8_t, sizeof(GifGCE));
-  if (gif_ptr->gce_ptr == NULL) {
+  if (!gif_ptr->gce_ptr) {
     FX_Free(gif_ptr->image_info_ptr);
     FX_Free(gif_ptr->lsd_ptr);
     FX_Free(gif_ptr->header_ptr);
     delete (gif_ptr->img_encoder_ptr);
     FX_Free(gif_ptr);
-    return NULL;
+    return nullptr;
   }
   gif_ptr->pte_ptr = (GifPTE*)FX_Alloc(uint8_t, sizeof(GifPTE));
-  if (gif_ptr->pte_ptr == NULL) {
+  if (!gif_ptr->pte_ptr) {
     FX_Free(gif_ptr->gce_ptr);
     FX_Free(gif_ptr->image_info_ptr);
     FX_Free(gif_ptr->lsd_ptr);
     FX_Free(gif_ptr->header_ptr);
     delete (gif_ptr->img_encoder_ptr);
     FX_Free(gif_ptr);
-    return NULL;
+    return nullptr;
   }
   FXSYS_memset(gif_ptr->pte_ptr, 0, sizeof(GifPTE));
   gif_ptr->pte_ptr->block_size = 12;
   return gif_ptr;
 }
 void gif_destroy_compress(gif_compress_struct_pp gif_ptr_ptr) {
-  if (gif_ptr_ptr == NULL || *gif_ptr_ptr == NULL) {
+  if (!gif_ptr_ptr || !*gif_ptr_ptr)
     return;
-  }
+
   gif_compress_struct_p gif_ptr = *gif_ptr_ptr;
-  *gif_ptr_ptr = NULL;
+  *gif_ptr_ptr = nullptr;
   FX_Free(gif_ptr->header_ptr);
   FX_Free(gif_ptr->lsd_ptr);
   FX_Free(gif_ptr->global_pal);
   FX_Free(gif_ptr->image_info_ptr);
   FX_Free(gif_ptr->local_pal);
   delete gif_ptr->img_encoder_ptr;
   FX_Free(gif_ptr->gce_ptr);
   FX_Free(gif_ptr->cmt_data_ptr);
   FX_Free(gif_ptr->pte_ptr);
   FX_Free(gif_ptr);
 }
 void gif_error(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) {
   if (gif_ptr && gif_ptr->gif_error_fn) {
     gif_ptr->gif_error_fn(gif_ptr, err_msg);
   }
 }
 void gif_warn(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) {}
 int32_t gif_read_header(gif_decompress_struct_p gif_ptr) {
-  if (gif_ptr == NULL) {
+  if (!gif_ptr)
     return 0;
-  }
+
   uint32_t skip_size_org = gif_ptr->skip_size;
   ASSERT(sizeof(GifHeader) == 6);
-  GifHeader* gif_header_ptr = NULL;
-  if (gif_read_data(gif_ptr, (uint8_t**)&gif_header_ptr, 6) == NULL) {
+  GifHeader* gif_header_ptr = nullptr;
+  if (!gif_read_data(gif_ptr, (uint8_t**)&gif_header_ptr, 6))
     return 2;
-  }
+
   if (FXSYS_strncmp(gif_header_ptr->signature, GIF_SIGNATURE, 3) != 0 ||
       gif_header_ptr->version[0] != '8' || gif_header_ptr->version[2] != 'a') {
     gif_error(gif_ptr, "Not A Gif Image");
     return 0;
   }
   ASSERT(sizeof(GifLSD) == 7);
-  GifLSD* gif_lsd_ptr = NULL;
-  if (gif_read_data(gif_ptr, (uint8_t**)&gif_lsd_ptr, 7) == NULL) {
+  GifLSD* gif_lsd_ptr = nullptr;
+  if (!gif_read_data(gif_ptr, (uint8_t**)&gif_lsd_ptr, 7)) {
     gif_ptr->skip_size = skip_size_org;
     return 2;
   }
   if (((GifGF*)&gif_lsd_ptr->global_flag)->global_pal) {
     gif_ptr->global_pal_num = 2
                               << ((GifGF*)&gif_lsd_ptr->global_flag)->pal_bits;
     ASSERT(sizeof(GifPalette) == 3);
     int32_t global_pal_size = gif_ptr->global_pal_num * 3;
-    uint8_t* global_pal_ptr = NULL;
-    if (gif_read_data(gif_ptr, &global_pal_ptr, global_pal_size) == NULL) {
+    uint8_t* global_pal_ptr = nullptr;
+    if (!gif_read_data(gif_ptr, &global_pal_ptr, global_pal_size)) {
       gif_ptr->skip_size = skip_size_org;
       return 2;
     }
     gif_ptr->global_sort_flag = ((GifGF*)&gif_lsd_ptr->global_flag)->sort_flag;
     gif_ptr->global_color_resolution =
         ((GifGF*)&gif_lsd_ptr->global_flag)->color_resolution;
     FX_Free(gif_ptr->global_pal_ptr);
     gif_ptr->global_pal_ptr = (GifPalette*)FX_Alloc(uint8_t, global_pal_size);
     FXSYS_memcpy(gif_ptr->global_pal_ptr, global_pal_ptr, global_pal_size);
   }
   gif_ptr->width = (int)GetWord_LSBFirst((uint8_t*)&gif_lsd_ptr->width);
   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 == NULL) {
+  if (!gif_ptr)
     return 0;
-  }
+
   int32_t ret = 1;
   while (TRUE) {
     switch (gif_ptr->decode_status) {
       case GIF_D_STATUS_TAIL:
         return 1;
       case GIF_D_STATUS_SIG: {
-        uint8_t* sig_ptr = NULL;
-        if (gif_read_data(gif_ptr, &sig_ptr, 1) == NULL) {
+        uint8_t* sig_ptr = nullptr;
+        if (!gif_read_data(gif_ptr, &sig_ptr, 1))
           return 2;
-        }
+
         switch (*sig_ptr) {
           case GIF_SIG_EXTENSION:
             gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT);
             continue;
           case GIF_SIG_IMAGE:
             gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_INFO);
             continue;
           case GIF_SIG_TRAILER:
             gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
             return 1;
           default:
             if (gif_ptr->avail_in) {
               gif_warn(gif_ptr, "The Gif File has non_standard Tag!");
               gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG);
               continue;
             }
             gif_warn(gif_ptr, "The Gif File Doesn't have Trailer Tag!");
             return 1;
         }
       }
       case GIF_D_STATUS_EXT: {
-        uint8_t* ext_ptr = NULL;
-        if (gif_read_data(gif_ptr, &ext_ptr, 1) == NULL) {
+        uint8_t* ext_ptr = nullptr;
+        if (!gif_read_data(gif_ptr, &ext_ptr, 1))
           return 2;
-        }
+
         switch (*ext_ptr) {
           case GIF_BLOCK_CE:
             gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT_CE);
             continue;
           case GIF_BLOCK_GCE:
             gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT_GCE);
             continue;
           case GIF_BLOCK_PTE:
             gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT_PTE);
             continue;
           default: {
             int32_t status = GIF_D_STATUS_EXT_UNE;
             if (*ext_ptr == GIF_BLOCK_PTE) {
               status = GIF_D_STATUS_EXT_PTE;
             }
             gif_save_decoding_status(gif_ptr, status);
             continue;
           }
         }
       }
       case GIF_D_STATUS_IMG_INFO: {
         ret = gif_decode_image_info(gif_ptr);
         if (ret != 1) {
           return ret;
         }
         continue;
       }
       case GIF_D_STATUS_IMG_DATA: {
-        uint8_t* data_size_ptr = NULL;
-        uint8_t* data_ptr = NULL;
+        uint8_t* data_size_ptr = nullptr;
+        uint8_t* data_ptr = nullptr;
         uint32_t skip_size_org = gif_ptr->skip_size;
-        if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+        if (!gif_read_data(gif_ptr, &data_size_ptr, 1))
           return 2;
-        }
+
         while (*data_size_ptr != GIF_BLOCK_TERMINAL) {
-          if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL) {
+          if (!gif_read_data(gif_ptr, &data_ptr, *data_size_ptr)) {
             gif_ptr->skip_size = skip_size_org;
             return 2;
           }
           gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
           skip_size_org = gif_ptr->skip_size;
-          if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+          if (!gif_read_data(gif_ptr, &data_size_ptr, 1))
             return 2;
-          }
         }
         gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG);
         continue;
       }
       default: {
         ret = gif_decode_extension(gif_ptr);
         if (ret != 1) {
           return ret;
         }
         continue;
       }
     }
   }
   return 1;
 }
 void gif_takeover_gce_ptr(gif_decompress_struct_p gif_ptr,
                           GifGCE** gce_ptr_ptr) {
-  *gce_ptr_ptr = NULL;
+  *gce_ptr_ptr = nullptr;
   if (gif_ptr->gce_ptr && gce_ptr_ptr) {
     *gce_ptr_ptr = gif_ptr->gce_ptr;
-    gif_ptr->gce_ptr = NULL;
+    gif_ptr->gce_ptr = nullptr;
   }
 }
 int32_t gif_decode_extension(gif_decompress_struct_p gif_ptr) {
-  uint8_t* data_size_ptr = NULL;
-  uint8_t* data_ptr = NULL;
+  uint8_t* data_size_ptr = nullptr;
+  uint8_t* data_ptr = nullptr;
   uint32_t skip_size_org = gif_ptr->skip_size;
   switch (gif_ptr->decode_status) {
     case GIF_D_STATUS_EXT_CE: {
-      if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+      if (!gif_read_data(gif_ptr, &data_size_ptr, 1)) {
         gif_ptr->skip_size = skip_size_org;
         return 2;
       }
       gif_ptr->cmt_data_ptr->clear();
       while (*data_size_ptr != GIF_BLOCK_TERMINAL) {
         uint8_t data_size = *data_size_ptr;
-        if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
-            gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+        if (!gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) ||
+            !gif_read_data(gif_ptr, &data_size_ptr, 1)) {
           gif_ptr->skip_size = skip_size_org;
           return 2;
         }
         *(gif_ptr->cmt_data_ptr) +=
             CFX_ByteString((const FX_CHAR*)data_ptr, data_size);
       }
     } break;
     case GIF_D_STATUS_EXT_PTE: {
       ASSERT(sizeof(GifPTE) == 13);
-      GifPTE* gif_pte_ptr = NULL;
-      if (gif_read_data(gif_ptr, (uint8_t**)&gif_pte_ptr, 13) == NULL) {
+      GifPTE* gif_pte_ptr = nullptr;
+      if (!gif_read_data(gif_ptr, (uint8_t**)&gif_pte_ptr, 13)) {
         return 2;
       }
       GifPlainText* gif_pt_ptr = FX_Alloc(GifPlainText, 1);
       FXSYS_memset(gif_pt_ptr, 0, sizeof(GifPlainText));
       gif_takeover_gce_ptr(gif_ptr, &gif_pt_ptr->gce_ptr);
       gif_pt_ptr->pte_ptr = (GifPTE*)FX_Alloc(uint8_t, sizeof(GifPTE));
       gif_pt_ptr->string_ptr = new CFX_ByteString;
       gif_pt_ptr->pte_ptr->block_size = gif_pte_ptr->block_size;
       gif_pt_ptr->pte_ptr->grid_left =
           GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_left);
       gif_pt_ptr->pte_ptr->grid_top =
           GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_top);
       gif_pt_ptr->pte_ptr->grid_width =
           GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_width);
       gif_pt_ptr->pte_ptr->grid_height =
           GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_height);
       gif_pt_ptr->pte_ptr->char_width = gif_pte_ptr->char_width;
       gif_pt_ptr->pte_ptr->char_height = gif_pte_ptr->char_height;
       gif_pt_ptr->pte_ptr->fc_index = gif_pte_ptr->fc_index;
       gif_pt_ptr->pte_ptr->bc_index = gif_pte_ptr->bc_index;
-      if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+      if (!gif_read_data(gif_ptr, &data_size_ptr, 1)) {
         gif_ptr->skip_size = skip_size_org;
         if (gif_pt_ptr) {
           FX_Free(gif_pt_ptr->gce_ptr);
           FX_Free(gif_pt_ptr->pte_ptr);
           delete gif_pt_ptr->string_ptr;
           FX_Free(gif_pt_ptr);
         }
         return 2;
       }
       while (*data_size_ptr != GIF_BLOCK_TERMINAL) {
         uint8_t data_size = *data_size_ptr;
-        if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
-            gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+        if (!gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) ||
+            !gif_read_data(gif_ptr, &data_size_ptr, 1)) {
           gif_ptr->skip_size = skip_size_org;
           if (gif_pt_ptr) {
             FX_Free(gif_pt_ptr->gce_ptr);
             FX_Free(gif_pt_ptr->pte_ptr);
             delete gif_pt_ptr->string_ptr;
             FX_Free(gif_pt_ptr);
           }
           return 2;
         }
         *(gif_pt_ptr->string_ptr) +=
             CFX_ByteString((const FX_CHAR*)data_ptr, data_size);
       }
       gif_ptr->pt_ptr_arr_ptr->Add(gif_pt_ptr);
     } break;
     case GIF_D_STATUS_EXT_GCE: {
       ASSERT(sizeof(GifGCE) == 5);
-      GifGCE* gif_gce_ptr = NULL;
-      if (gif_read_data(gif_ptr, (uint8_t**)&gif_gce_ptr, 6) == NULL) {
+      GifGCE* gif_gce_ptr = nullptr;
+      if (!gif_read_data(gif_ptr, (uint8_t**)&gif_gce_ptr, 6))
         return 2;
-      }
-      if (gif_ptr->gce_ptr == NULL) {
+
+      if (!gif_ptr->gce_ptr)
         gif_ptr->gce_ptr = (GifGCE*)FX_Alloc(uint8_t, sizeof(GifGCE));
-      }
       gif_ptr->gce_ptr->block_size = gif_gce_ptr->block_size;
       gif_ptr->gce_ptr->gce_flag = gif_gce_ptr->gce_flag;
       gif_ptr->gce_ptr->delay_time =
           GetWord_LSBFirst((uint8_t*)&gif_gce_ptr->delay_time);
       gif_ptr->gce_ptr->trans_index = gif_gce_ptr->trans_index;
     } break;
     default: {
       if (gif_ptr->decode_status == GIF_D_STATUS_EXT_PTE) {
         FX_Free(gif_ptr->gce_ptr);
-        gif_ptr->gce_ptr = NULL;
+        gif_ptr->gce_ptr = nullptr;
       }
-      if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+      if (!gif_read_data(gif_ptr, &data_size_ptr, 1))
         return 2;
-      }
+
       while (*data_size_ptr != GIF_BLOCK_TERMINAL) {
-        if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
-            gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+        if (!gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) ||
+            !gif_read_data(gif_ptr, &data_size_ptr, 1)) {
           gif_ptr->skip_size = skip_size_org;
           return 2;
         }
       }
     }
   }
   gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG);
   return 1;
 }
 int32_t gif_decode_image_info(gif_decompress_struct_p gif_ptr) {
   if (gif_ptr->width == 0 || gif_ptr->height == 0) {
     gif_error(gif_ptr, "No Image Header Info");
     return 0;
   }
   uint32_t skip_size_org = gif_ptr->skip_size;
   ASSERT(sizeof(GifImageInfo) == 9);
-  GifImageInfo* gif_img_info_ptr = NULL;
-  if (gif_read_data(gif_ptr, (uint8_t**)&gif_img_info_ptr, 9) == NULL) {
+  GifImageInfo* gif_img_info_ptr = nullptr;
+  if (!gif_read_data(gif_ptr, (uint8_t**)&gif_img_info_ptr, 9))
     return 2;
-  }
+
   GifImage* gif_image_ptr = (GifImage*)FX_Alloc(uint8_t, sizeof(GifImage));
   FXSYS_memset(gif_image_ptr, 0, sizeof(GifImage));
   gif_image_ptr->image_info_ptr =
       (GifImageInfo*)FX_Alloc(uint8_t, sizeof(GifImageInfo));
   gif_image_ptr->image_info_ptr->left =
       GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->left);
   gif_image_ptr->image_info_ptr->top =
       GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->top);
   gif_image_ptr->image_info_ptr->width =
       GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->width);
   gif_image_ptr->image_info_ptr->height =
       GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->height);
   gif_image_ptr->image_info_ptr->local_flag = gif_img_info_ptr->local_flag;
   if (gif_image_ptr->image_info_ptr->left +
               gif_image_ptr->image_info_ptr->width >
           gif_ptr->width ||
       gif_image_ptr->image_info_ptr->top +
               gif_image_ptr->image_info_ptr->height >
           gif_ptr->height) {
     FX_Free(gif_image_ptr->image_info_ptr);
     FX_Free(gif_image_ptr->image_row_buf);
     FX_Free(gif_image_ptr);
     gif_error(gif_ptr, "Image Data Out Of LSD, The File May Be Corrupt");
     return 0;
   }
   GifLF* gif_img_info_lf_ptr = (GifLF*)&gif_img_info_ptr->local_flag;
   if (gif_img_info_lf_ptr->local_pal) {
     ASSERT(sizeof(GifPalette) == 3);
     int32_t loc_pal_size = (2 << gif_img_info_lf_ptr->pal_bits) * 3;
-    uint8_t* loc_pal_ptr = NULL;
-    if (gif_read_data(gif_ptr, &loc_pal_ptr, loc_pal_size) == NULL) {
+    uint8_t* loc_pal_ptr = nullptr;
+    if (!gif_read_data(gif_ptr, &loc_pal_ptr, loc_pal_size)) {
       gif_ptr->skip_size = skip_size_org;
       FX_Free(gif_image_ptr->image_info_ptr);
       FX_Free(gif_image_ptr->image_row_buf);
       FX_Free(gif_image_ptr);
       return 2;
     }
     gif_image_ptr->local_pal_ptr =
         (GifPalette*)gif_ptr->gif_ask_buf_for_pal_fn(gif_ptr, loc_pal_size);
     if (gif_image_ptr->local_pal_ptr) {
       FXSYS_memcpy((uint8_t*)gif_image_ptr->local_pal_ptr, loc_pal_ptr,
                    loc_pal_size);
     }
   }
-  uint8_t* code_size_ptr = NULL;
-  if (gif_read_data(gif_ptr, &code_size_ptr, 1) == NULL) {
+  uint8_t* code_size_ptr = nullptr;
+  if (!gif_read_data(gif_ptr, &code_size_ptr, 1)) {
     gif_ptr->skip_size = skip_size_org;
     FX_Free(gif_image_ptr->image_info_ptr);
     FX_Free(gif_image_ptr->local_pal_ptr);
     FX_Free(gif_image_ptr->image_row_buf);
     FX_Free(gif_image_ptr);
     return 2;
   }
   gif_image_ptr->image_code_size = *code_size_ptr;
   gif_ptr->gif_record_current_position_fn(gif_ptr,
                                           &gif_image_ptr->image_data_pos);
   gif_image_ptr->image_data_pos += gif_ptr->skip_size;
   gif_takeover_gce_ptr(gif_ptr, &gif_image_ptr->image_gce_ptr);
   gif_ptr->img_ptr_arr_ptr->Add(gif_image_ptr);
   gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
   return 1;
 }
 int32_t gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
-  if (gif_ptr == NULL || frame_num < 0 ||
+  if (!gif_ptr || frame_num < 0 ||
       frame_num >= gif_ptr->img_ptr_arr_ptr->GetSize()) {
     return 0;
   }
-  uint8_t* data_size_ptr = NULL;
-  uint8_t* data_ptr = NULL;
+  uint8_t* data_size_ptr = nullptr;
+  uint8_t* data_ptr = nullptr;
   uint32_t skip_size_org = gif_ptr->skip_size;
   GifImage* gif_image_ptr = gif_ptr->img_ptr_arr_ptr->GetAt(frame_num);
   uint32_t gif_img_row_bytes = gif_image_ptr->image_info_ptr->width;
   if (gif_ptr->decode_status == GIF_D_STATUS_TAIL) {
     if (gif_image_ptr->image_row_buf) {
       FX_Free(gif_image_ptr->image_row_buf);
-      gif_image_ptr->image_row_buf = NULL;
+      gif_image_ptr->image_row_buf = nullptr;
     }
     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 == NULL) {
+    if (!gif_img_gce_ptr) {
       FX_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)
               ->interlace);
       if (!bRes) {
         FX_Free(gif_image_ptr->image_row_buf);
-        gif_image_ptr->image_row_buf = NULL;
+        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(
           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,
           ((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)
               ->interlace);
       if (!bRes) {
         FX_Free(gif_image_ptr->image_row_buf);
-        gif_image_ptr->image_row_buf = NULL;
+        gif_image_ptr->image_row_buf = nullptr;
         gif_error(gif_ptr, "Error Read Record Position Data");
         return 0;
       }
     }
-    if (gif_ptr->img_decoder_ptr == NULL) {
+    if (!gif_ptr->img_decoder_ptr)
       gif_ptr->img_decoder_ptr = new CGifLZWDecoder(gif_ptr->err_ptr);
-    }
     gif_ptr->img_decoder_ptr->InitTable(gif_image_ptr->image_code_size);
     gif_ptr->img_row_offset = 0;
     gif_ptr->img_row_avail_size = 0;
     gif_ptr->img_pass_num = 0;
     gif_image_ptr->image_row_num = 0;
     gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
   }
   CGifLZWDecoder* img_decoder_ptr = gif_ptr->img_decoder_ptr;
   if (gif_ptr->decode_status == GIF_D_STATUS_IMG_DATA) {
-    if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+    if (!gif_read_data(gif_ptr, &data_size_ptr, 1))
       return 2;
-    }
+
     if (*data_size_ptr != GIF_BLOCK_TERMINAL) {
-      if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL) {
+      if (!gif_read_data(gif_ptr, &data_ptr, *data_size_ptr)) {
         gif_ptr->skip_size = skip_size_org;
         return 2;
       }
       img_decoder_ptr->Input(data_ptr, *data_size_ptr);
       gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
       gif_ptr->img_row_offset += gif_ptr->img_row_avail_size;
       gif_ptr->img_row_avail_size = gif_img_row_bytes - gif_ptr->img_row_offset;
       int32_t ret = img_decoder_ptr->Decode(
           gif_image_ptr->image_row_buf + gif_ptr->img_row_offset,
           gif_ptr->img_row_avail_size);
       if (ret == 0) {
         FX_Free(gif_image_ptr->image_row_buf);
-        gif_image_ptr->image_row_buf = NULL;
+        gif_image_ptr->image_row_buf = nullptr;
         gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
         gif_error(gif_ptr, "Decode Image Data Error");
         return 0;
       }
       while (ret != 0) {
         if (ret == 1) {
           gif_ptr->gif_get_row_fn(gif_ptr, gif_image_ptr->image_row_num,
                                   gif_image_ptr->image_row_buf);
           FX_Free(gif_image_ptr->image_row_buf);
-          gif_image_ptr->image_row_buf = NULL;
+          gif_image_ptr->image_row_buf = nullptr;
           gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
           return 1;
         }
         if (ret == 2) {
           ASSERT(img_decoder_ptr->GetAvailInput() == 0);
           skip_size_org = gif_ptr->skip_size;
-          if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+          if (!gif_read_data(gif_ptr, &data_size_ptr, 1))
             return 2;
-          }
+
           if (*data_size_ptr != GIF_BLOCK_TERMINAL) {
-            if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL) {
+            if (!gif_read_data(gif_ptr, &data_ptr, *data_size_ptr)) {
               gif_ptr->skip_size = skip_size_org;
               return 2;
             }
             img_decoder_ptr->Input(data_ptr, *data_size_ptr);
             gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
             gif_ptr->img_row_offset += gif_ptr->img_row_avail_size;
             gif_ptr->img_row_avail_size =
                 gif_img_row_bytes - gif_ptr->img_row_offset;
             ret = img_decoder_ptr->Decode(
                 gif_image_ptr->image_row_buf + gif_ptr->img_row_offset,
@@ skipping 17 matching lines @@
                                     gif_image_ptr->image_row_buf);
           }
           gif_ptr->img_row_offset = 0;
           gif_ptr->img_row_avail_size = gif_img_row_bytes;
           ret = img_decoder_ptr->Decode(
               gif_image_ptr->image_row_buf + gif_ptr->img_row_offset,
               gif_ptr->img_row_avail_size);
         }
         if (ret == 0) {
           FX_Free(gif_image_ptr->image_row_buf);
-          gif_image_ptr->image_row_buf = NULL;
+          gif_image_ptr->image_row_buf = nullptr;
           gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
           gif_error(gif_ptr, "Decode Image Data Error");
           return 0;
         }
       }
     }
     gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
   }
   gif_error(gif_ptr, "Decode Image Data Error");
   return 0;
 }
 void gif_save_decoding_status(gif_decompress_struct_p gif_ptr, int32_t status) {
   gif_ptr->decode_status = status;
   gif_ptr->next_in += gif_ptr->skip_size;
   gif_ptr->avail_in -= gif_ptr->skip_size;
   gif_ptr->skip_size = 0;
 }
 uint8_t* gif_read_data(gif_decompress_struct_p gif_ptr,
                        uint8_t** des_buf_pp,
                        uint32_t data_size) {
-  if (gif_ptr == NULL || gif_ptr->avail_in < gif_ptr->skip_size + data_size) {
-    return NULL;
-  }
+  if (!gif_ptr || gif_ptr->avail_in < gif_ptr->skip_size + data_size)
+    return nullptr;
+
   *des_buf_pp = gif_ptr->next_in + gif_ptr->skip_size;
   gif_ptr->skip_size += data_size;
   return *des_buf_pp;
 }
 void gif_input_buffer(gif_decompress_struct_p gif_ptr,
                       uint8_t* src_buf,
                       uint32_t src_size) {
   gif_ptr->next_in = src_buf;
   gif_ptr->avail_in = src_size;
   gif_ptr->skip_size = 0;
 }
 uint32_t gif_get_avail_input(gif_decompress_struct_p gif_ptr,
                              uint8_t** avial_buf_ptr) {
   if (avial_buf_ptr) {

[Tom Sepez, 2016/06/02 20:09:49]

nit: sp. avial vs avail

[Lei Zhang, 2016/06/07 07:33:23]

Done.

-    *avial_buf_ptr = NULL;
+    *avial_buf_ptr = nullptr;
     if (gif_ptr->avail_in > 0) {
       *avial_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) {
   if (gif_ptr->cur_offset) {
     return TRUE;
   }
   dst_len = sizeof(GifHeader) + sizeof(GifLSD) + sizeof(GifGF);
   dst_buf = FX_TryAlloc(uint8_t, dst_len);
-  if (dst_buf == NULL) {
+  if (!dst_buf)
     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;
@@ skipping 17 matching lines @@
     if (row % 8 == 0) {
       j = 0;
     } else if (row % 4 == 0) {
       j = 1;
     } else if (row % 2 == 0) {
       j = 2;
     } else {
       j = 3;
     }
     temp = FX_Alloc(uint8_t, pitch);
-    if (temp == NULL) {
-      return;
-    }
     FXSYS_memcpy(temp, &buf[pitch * row], pitch);
     pass[j].Add(temp);
     row++;
   }
   for (i = 0, row = 0; i < 4; i++) {
     for (j = 0; j < pass[i].GetSize(); j++, row++) {
       FXSYS_memcpy((uint8_t*)&buf[pitch * row], pass[i].GetAt(j), pitch);
       FX_Free(pass[i].GetAt(j));
     }
   }
@@ skipping 137 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;
 }