Clean up fx_basic_util a little

core/fxcrt/fx_basic_util.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/fxcrt/fx_basic.h"
 #include "core/fxcrt/fx_ext.h"
 
 #if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
@@ skipping 67 matching lines @@
 
   int* pInt = static_cast<int*>(pData);
   *pInt = value;
   return true;
 }
 
 static const FX_FLOAT fraction_scales[] = {
     0.1f,         0.01f,         0.001f,        0.0001f,
     0.00001f,     0.000001f,     0.0000001f,    0.00000001f,
     0.000000001f, 0.0000000001f, 0.00000000001f};
+
 int FXSYS_FractionalScaleCount() {
   return FX_ArraySize(fraction_scales);
 }
 
 FX_FLOAT FXSYS_FractionalScale(size_t scale_factor, int value) {
   return fraction_scales[scale_factor] * value;
 }
 
 FX_FLOAT FX_atof(const CFX_ByteStringC& strc) {
   if (strc.IsEmpty())
     return 0.0;
 
   int cc = 0;
   bool bNegative = false;
   int len = strc.GetLength();
   if (strc[0] == '+') {
     cc++;
   } else if (strc[0] == '-') {
     bNegative = TRUE;
     cc++;
   }
   while (cc < len) {
-    if (strc[cc] != '+' && strc[cc] != '-') {
+    if (strc[cc] != '+' && strc[cc] != '-')
       break;
-    }
     cc++;
   }
   FX_FLOAT value = 0;
   while (cc < len) {
-    if (strc[cc] == '.') {
+    if (strc[cc] == '.')
       break;
-    }
     value = value * 10 + FXSYS_toDecimalDigit(strc.CharAt(cc));
     cc++;
   }
   int scale = 0;
   if (cc < len && strc[cc] == '.') {
     cc++;
     while (cc < len) {
       value +=
           FXSYS_FractionalScale(scale, FXSYS_toDecimalDigit(strc.CharAt(cc)));
       scale++;
       if (scale == FXSYS_FractionalScaleCount())
         break;
       cc++;
     }
   }
   return bNegative ? -value : value;
 }
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ && _MSC_VER < 1900
 void FXSYS_snprintf(char* str,
                     size_t size,
                     _Printf_format_string_ const char* fmt,
                     ...) {
   va_list ap;
   va_start(ap, fmt);
   FXSYS_vsnprintf(str, size, fmt, ap);
   va_end(ap);
 }
+
 void FXSYS_vsnprintf(char* str, size_t size, const char* fmt, va_list ap) {
   (void)_vsnprintf(str, size, fmt, ap);
-  if (size) {
+  if (size)
     str[size - 1] = 0;
-  }
 }
 #endif  // _FXM_PLATFORM_WINDOWS_ && _MSC_VER < 1900
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 class CFindFileData {
  public:
   virtual ~CFindFileData() {}
   HANDLE m_Handle;
-  FX_BOOL m_bEnd;
+  bool m_bEnd;
 };
 
 class CFindFileDataA : public CFindFileData {
  public:
   ~CFindFileDataA() override {}
   WIN32_FIND_DATAA m_FindData;
 };
 
 class CFindFileDataW : public CFindFileData {
  public:
   ~CFindFileDataW() override {}
   WIN32_FIND_DATAW m_FindData;
 };
 #endif
 
 void* FX_OpenFolder(const FX_CHAR* path) {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
   std::unique_ptr<CFindFileDataA> pData(new CFindFileDataA);
   pData->m_Handle = FindFirstFileExA((CFX_ByteString(path) + "/*.*").c_str(),
                                      FindExInfoStandard, &pData->m_FindData,
                                      FindExSearchNameMatch, nullptr, 0);
   if (pData->m_Handle == INVALID_HANDLE_VALUE)
     return nullptr;
 
-  pData->m_bEnd = FALSE;
+  pData->m_bEnd = false;
   return pData.release();
 #else
   DIR* dir = opendir(path);
   return dir;
 #endif
 }
 
-void* FX_OpenFolder(const FX_WCHAR* path) {
-#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
-  std::unique_ptr<CFindFileDataW> pData(new CFindFileDataW);
-  pData->m_Handle = FindFirstFileExW((CFX_WideString(path) + L"/*.*").c_str(),
-                                     FindExInfoStandard, &pData->m_FindData,
-                                     FindExSearchNameMatch, nullptr, 0);
-  if (pData->m_Handle == INVALID_HANDLE_VALUE)
-    return nullptr;
+bool FX_GetNextFile(void* handle, CFX_ByteString& filename, bool& bFolder) {
+  if (!handle)
+    return false;
 
-  pData->m_bEnd = FALSE;
-  return pData.release();
-#else
-  DIR* dir = opendir(CFX_ByteString::FromUnicode(path).c_str());
-  return dir;
-#endif
-}
-FX_BOOL FX_GetNextFile(void* handle,
-                       CFX_ByteString& filename,
-                       FX_BOOL& bFolder) {
-  if (!handle) {
-    return FALSE;
-  }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_

[dsinclair, 2016/10/12 20:43:23]

Can we duplicate the method signature inside the #if's and then change the void*
handle into actual types?

[npm, 2016/10/12 22:13:19]

Cleaner: created typedef for file handle.

   CFindFileDataA* pData = (CFindFileDataA*)handle;
   if (pData->m_bEnd)
-    return FALSE;
+    return false;
 
   filename = pData->m_FindData.cFileName;
-  bFolder = pData->m_FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
+  bFolder =
+      (pData->m_FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
   if (!FindNextFileA(pData->m_Handle, &pData->m_FindData))
-    pData->m_bEnd = TRUE;
-  return TRUE;
+    pData->m_bEnd = true;
+  return true;
 #elif defined(__native_client__)

[dsinclair, 2016/10/12 20:43:23]

Do we even support building under __native_client__?

[npm, 2016/10/12 22:13:19]

Deleted... Tom?

   abort();
-  return FALSE;
+  return false;
 #else
   struct dirent* de = readdir((DIR*)handle);
-  if (!de) {
-    return FALSE;
-  }
+  if (!de)
+    return false;
   filename = de->d_name;
   bFolder = de->d_type == DT_DIR;
-  return TRUE;
+  return true;
 #endif
 }
-FX_BOOL FX_GetNextFile(void* handle,
-                       CFX_WideString& filename,
-                       FX_BOOL& bFolder) {
-  if (!handle) {
-    return FALSE;
-  }
-#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
-  CFindFileDataW* pData = (CFindFileDataW*)handle;
-  if (pData->m_bEnd) {
-    return FALSE;
-  }
-  filename = pData->m_FindData.cFileName;
-  bFolder = pData->m_FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
-  if (!FindNextFileW(pData->m_Handle, &pData->m_FindData)) {
-    pData->m_bEnd = TRUE;
-  }
-  return TRUE;
-#elif defined(__native_client__)
-  abort();
-  return FALSE;
-#else
-  struct dirent* de = readdir((DIR*)handle);
-  if (!de) {
-    return FALSE;
-  }
-  filename = CFX_WideString::FromLocal(de->d_name);
-  bFolder = de->d_type == DT_DIR;
-  return TRUE;
-#endif
-}
+
 void FX_CloseFolder(void* handle) {
-  if (!handle) {
+  if (!handle)
     return;
-  }
+
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
   CFindFileData* pData = (CFindFileData*)handle;
   FindClose(pData->m_Handle);
   delete pData;
 #else
   closedir((DIR*)handle);
 #endif
 }
+
 FX_WCHAR FX_GetFolderSeparator() {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
   return '\\';
 #else
   return '/';
 #endif
 }
 
 CFX_Matrix_3by3 CFX_Matrix_3by3::Inverse() {
   FX_FLOAT det =
@@ skipping 32 matching lines @@
   if (nbits < 8 && nbits + bitCount <= 8) {
     bitShift = 8 - nbits - bitCount;
     bitMask = (1 << nbits) - 1;
     dstShift = 0;
   } else {
     bitShift = 0;
     int bitOffset = 8 - bitCount;
     bitMask = (1 << std::min(bitOffset, nbits)) - 1;
     dstShift = nbits - bitOffset;
   }
-  uint32_t result = (uint32_t)(*dataPtr++ >> bitShift & bitMask) << dstShift;
+  uint32_t result =
+      static_cast<uint32_t>((*dataPtr++ >> bitShift & bitMask) << dstShift);
   while (dstShift >= 8) {
     dstShift -= 8;
     result |= *dataPtr++ << dstShift;
   }
   if (dstShift > 0) {
     bitShift = 8 - dstShift;
     bitMask = (1 << dstShift) - 1;
     result |= *dataPtr++ >> bitShift & bitMask;
   }
   return result;
 }