AutoBuff.hpp

// AutoBuff.hpp --- C++/Win32 auto-buffering framework
// Author: katahiromz
// License: MIT

#pragma once

#if !defined(__cplusplus) || (__cplusplus < 201103L)
#error AutoBuff.hpp requires C++11 or later.
#endif

#ifndef _INC_WINDOWS
#include <windows.h>
#endif

#include <string>
#include <vector>
#include <stdarg.h>

#ifndef AUTOBUFF_MAX
#define AUTOBUFF_MAX 65536
#endif

namespace AutoBuff_internal {
template <typename TChar, typename TFunc>
inline DWORD call_with_retry(std::basic_string<TChar>& str, TFunc func) {
  DWORD size = func(nullptr, 0);
  if (size > 0) {
    str.resize(size - 1);
    DWORD written = func(&str[0], size);
    str.resize(written);
    return written;
  }
  str.clear();
  return 0;
}

template <typename TChar, typename TFunc>
inline DWORD call_with_expand(std::basic_string<TChar>& str, TFunc func) {
  DWORD size = MAX_PATH;
  while (true) {
    str.resize(size);
    DWORD res = func(&str[0], size);
    if (res < size - 1) {
      str.resize(res);
      return res;
    }
    size *= 2;
    if (size > AUTOBUFF_MAX) break;
  }
  return 0;
}
}  // namespace AutoBuff_internal

inline UINT AutoBuff_GetAtomNameA(ATOM nAtom, std::string& str) {
  char buf[256];
  UINT res = GetAtomNameA(nAtom, buf, 256);
  if (res > 0) str = buf;
  return res;
}
inline UINT AutoBuff_GetAtomNameW(ATOM nAtom, std::wstring& str) {
  wchar_t buf[256];
  UINT res = GetAtomNameW(nAtom, buf, 256);
  if (res > 0) str = buf;
  return res;
}

inline BOOL AutoBuff_GetComputerNameA(std::string& str) {
  DWORD s = 0;
  GetComputerNameA(NULL, &s);
  if (s == 0) {
    str.clear();
    return FALSE;
  }
  str.resize(s);
  BOOL ret = GetComputerNameA(&str[0], &s);
  if (ret)
    str.resize(s);
  else
    str.clear();
  return ret;
}
inline BOOL AutoBuff_GetComputerNameW(std::wstring& str) {
  DWORD s = 0;
  GetComputerNameW(NULL, &s);
  if (s == 0) {
    str.clear();
    return FALSE;
  }
  str.resize(s);
  BOOL ret = GetComputerNameW(&str[0], &s);
  if (ret)
    str.resize(s);
  else
    str.clear();
  return ret;
}

inline BOOL AutoBuff_GetComputerNameExA(COMPUTER_NAME_FORMAT t,
                                        std::string& str) {
  DWORD s = 0;
  GetComputerNameExA(t, NULL, &s);
  if (s == 0) {
    str.clear();
    return FALSE;
  }
  str.resize(s);
  BOOL ret = GetComputerNameExA(t, &str[0], &s);
  if (ret)
    str.resize(s);
  else
    str.clear();
  return ret;
}
inline BOOL AutoBuff_GetComputerNameExW(COMPUTER_NAME_FORMAT t,
                                        std::wstring& str) {
  DWORD s = 0;
  GetComputerNameExW(t, NULL, &s);
  if (s == 0) {
    str.clear();
    return FALSE;
  }
  str.resize(s);
  BOOL ret = GetComputerNameExW(t, &str[0], &s);
  if (ret)
    str.resize(s);
  else
    str.clear();
  return ret;
}

inline DWORD AutoBuff_GetCurrentDirectoryA(std::string& str) {
  return AutoBuff_internal::call_with_retry(
      str, [](LPSTR b, DWORD s) { return GetCurrentDirectoryA(s, b); });
}
inline DWORD AutoBuff_GetCurrentDirectoryW(std::wstring& str) {
  return AutoBuff_internal::call_with_retry(
      str, [](LPWSTR b, DWORD s) { return GetCurrentDirectoryW(s, b); });
}

inline DWORD AutoBuff_GetEnvironmentVariableA(LPCSTR n, std::string& str) {
  return AutoBuff_internal::call_with_retry(
      str, [&](LPSTR b, DWORD s) { return GetEnvironmentVariableA(n, b, s); });
}
inline DWORD AutoBuff_GetEnvironmentVariableW(LPCWSTR n, std::wstring& str) {
  return AutoBuff_internal::call_with_retry(
      str, [&](LPWSTR b, DWORD s) { return GetEnvironmentVariableW(n, b, s); });
}

inline DWORD AutoBuff_GetFullPathNameA(LPCSTR f, std::string& str,
                                       LPSTR* p = nullptr) {
  return AutoBuff_internal::call_with_retry(
      str, [&](LPSTR b, DWORD s) { return GetFullPathNameA(f, s, b, p); });
}
inline DWORD AutoBuff_GetFullPathNameW(LPCWSTR f, std::wstring& str,
                                       LPWSTR* p = nullptr) {
  return AutoBuff_internal::call_with_retry(
      str, [&](LPWSTR b, DWORD s) { return GetFullPathNameW(f, s, b, p); });
}

inline DWORD AutoBuff_GetLogicalDriveStringsA(std::string& str) {
  return AutoBuff_internal::call_with_retry(
      str, [](LPSTR b, DWORD s) { return GetLogicalDriveStringsA(s, b); });
}
inline DWORD AutoBuff_GetLogicalDriveStringsW(std::wstring& str) {
  return AutoBuff_internal::call_with_retry(
      str, [](LPWSTR b, DWORD s) { return GetLogicalDriveStringsW(s, b); });
}

inline DWORD AutoBuff_GetLongPathNameA(LPCSTR l, std::string& str) {
  return AutoBuff_internal::call_with_retry(
      str, [&](LPSTR b, DWORD s) { return GetLongPathNameA(l, b, s); });
}
inline DWORD AutoBuff_GetLongPathNameW(LPCWSTR l, std::wstring& str) {
  return AutoBuff_internal::call_with_retry(
      str, [&](LPWSTR b, DWORD s) { return GetLongPathNameW(l, b, s); });
}

inline DWORD AutoBuff_GetShortPathNameA(LPCSTR l, std::string& str) {
  return AutoBuff_internal::call_with_retry(
      str, [&](LPSTR b, DWORD s) { return GetShortPathNameA(l, b, s); });
}
inline DWORD AutoBuff_GetShortPathNameW(LPCWSTR l, std::wstring& str) {
  return AutoBuff_internal::call_with_retry(
      str, [&](LPWSTR b, DWORD s) { return GetShortPathNameW(l, b, s); });
}

inline DWORD AutoBuff_GetModuleFileNameA(HMODULE h, std::string& str) {
  DWORD s = MAX_PATH;
  while (true) {
    str.resize(s);
    DWORD r = GetModuleFileNameA(h, &str[0], s);
    if (r < s) {
      str.resize(r);
      return r;
    }
    if (s > AUTOBUFF_MAX) {
      str.clear();
      return 0;
    }
    s *= 2;
  }
}
inline DWORD AutoBuff_GetModuleFileNameW(HMODULE h, std::wstring& str) {
  DWORD s = MAX_PATH;
  while (true) {
    str.resize(s);
    DWORD r = GetModuleFileNameW(h, &str[0], s);
    if (r < s) {
      str.resize(r);
      return r;
    }
    if (s > AUTOBUFF_MAX) {
      str.clear();
      return 0;
    }
    s *= 2;
  }
}

inline DWORD AutoBuff_GetPrivateProfileStringA(LPCSTR a, LPCSTR k, LPCSTR d,
                                               std::string& str, LPCSTR f) {
  return AutoBuff_internal::call_with_expand(str, [&](LPSTR b, DWORD s) {
    return GetPrivateProfileStringA(a, k, d, b, s, f);
  });
}
inline DWORD AutoBuff_GetPrivateProfileStringW(LPCWSTR a, LPCWSTR k, LPCWSTR d,
                                               std::wstring& str, LPCWSTR f) {
  return AutoBuff_internal::call_with_expand(str, [&](LPWSTR b, DWORD s) {
    return GetPrivateProfileStringW(a, k, d, b, s, f);
  });
}

inline DWORD AutoBuff_GetPrivateProfileSectionA(LPCSTR a, std::string& str,
                                                LPCSTR f) {
  return AutoBuff_internal::call_with_expand(str, [&](LPSTR b, DWORD s) {
    return GetPrivateProfileSectionA(a, b, s, f);
  });
}
inline DWORD AutoBuff_GetPrivateProfileSectionW(LPCWSTR a, std::wstring& str,
                                                LPCWSTR f) {
  return AutoBuff_internal::call_with_expand(str, [&](LPWSTR b, DWORD s) {
    return GetPrivateProfileSectionW(a, b, s, f);
  });
}

inline DWORD AutoBuff_GetPrivateProfileSectionNamesA(std::string& str,
                                                     LPCSTR f) {
  return AutoBuff_internal::call_with_expand(str, [&](LPSTR b, DWORD s) {
    return GetPrivateProfileSectionNamesA(b, s, f);
  });
}
inline DWORD AutoBuff_GetPrivateProfileSectionNamesW(std::wstring& str,
                                                     LPCWSTR f) {
  return AutoBuff_internal::call_with_expand(str, [&](LPWSTR b, DWORD s) {
    return GetPrivateProfileSectionNamesW(b, s, f);
  });
}

inline UINT AutoBuff_GetSystemDirectoryA(std::string& str) {
  return (UINT)AutoBuff_internal::call_with_retry(
      str, [](LPSTR b, UINT s) { return GetSystemDirectoryA(b, s); });
}
inline UINT AutoBuff_GetSystemDirectoryW(std::wstring& str) {
  return (UINT)AutoBuff_internal::call_with_retry(
      str, [](LPWSTR b, UINT s) { return GetSystemDirectoryW(b, s); });
}

inline UINT AutoBuff_GetWindowsDirectoryA(std::string& str) {
  return (UINT)AutoBuff_internal::call_with_retry(
      str, [](LPSTR b, UINT s) { return GetWindowsDirectoryA(b, s); });
}
inline UINT AutoBuff_GetWindowsDirectoryW(std::wstring& str) {
  return (UINT)AutoBuff_internal::call_with_retry(
      str, [](LPWSTR b, UINT s) { return GetWindowsDirectoryW(b, s); });
}

inline UINT AutoBuff_GetSystemWindowsDirectoryA(std::string& str) {
  return (UINT)AutoBuff_internal::call_with_retry(
      str, [](LPSTR b, UINT s) { return GetSystemWindowsDirectoryA(b, s); });
}
inline UINT AutoBuff_GetSystemWindowsDirectoryW(std::wstring& str) {
  return (UINT)AutoBuff_internal::call_with_retry(
      str, [](LPWSTR b, UINT s) { return GetSystemWindowsDirectoryW(b, s); });
}

inline UINT AutoBuff_GetTempPathA(std::string& str) {
  return (UINT)AutoBuff_internal::call_with_retry(
      str, [](LPSTR b, UINT s) { return GetTempPathA(s, b); });
}
inline UINT AutoBuff_GetTempPathW(std::wstring& str) {
  return (UINT)AutoBuff_internal::call_with_retry(
      str, [](LPWSTR b, UINT s) { return GetTempPathW(s, b); });
}

inline BOOL AutoBuff_GetUserNameA(std::string& str) {
  DWORD s = 0;
  GetUserNameA(NULL, &s);
  if (s == 0) return FALSE;
  str.resize(s - 1);
  return GetUserNameA(&str[0], &s);
}
inline BOOL AutoBuff_GetUserNameW(std::wstring& str) {
  DWORD s = 0;
  GetUserNameW(NULL, &s);
  if (s == 0) return FALSE;
  str.resize(s - 1);
  return GetUserNameW(&str[0], &s);
}

inline DWORD AutoBuff_GetConsoleTitleA(std::string& str) {
  return AutoBuff_internal::call_with_expand(
      str, [](LPSTR b, DWORD s) { return GetConsoleTitleA(b, s); });
}
inline DWORD AutoBuff_GetConsoleTitleW(std::wstring& str) {
  return AutoBuff_internal::call_with_expand(
      str, [](LPWSTR b, DWORD s) { return GetConsoleTitleW(b, s); });
}

inline int AutoBuff_GetWindowTextA(HWND h, std::string& str) {
  int l = GetWindowTextLengthA(h);
  if (l <= 0) {
    str.clear();
    return 0;
  }
  str.resize(l);
  int ret = GetWindowTextA(h, &str[0], l + 1);
  str.resize(ret);
  return ret;
}
inline int AutoBuff_GetWindowTextW(HWND h, std::wstring& str) {
  int l = GetWindowTextLengthW(h);
  if (l <= 0) {
    str.clear();
    return 0;
  }
  str.resize(l);
  int ret = GetWindowTextW(h, &str[0], l + 1);
  str.resize(ret);
  return ret;
}

inline UINT AutoBuff_GetDlgItemTextA(HWND hDlg, int nIDDlgItem,
                                     std::string& str) {
  HWND hWndItem = GetDlgItem(hDlg, nIDDlgItem);
  if (!hWndItem) return 0;
  return AutoBuff_GetWindowTextA(hWndItem, str);
}
inline UINT AutoBuff_GetDlgItemTextW(HWND hDlg, int nIDDlgItem,
                                     std::wstring& str) {
  HWND hWndItem = GetDlgItem(hDlg, nIDDlgItem);
  if (!hWndItem) return 0;
  return AutoBuff_GetWindowTextW(hWndItem, str);
}

inline int AutoBuff_LoadStringW(HINSTANCE h, UINT i, std::wstring& str) {
  LPCWSTR p = nullptr;
  int l = LoadStringW(h, i, reinterpret_cast<LPWSTR>(&p), 0);
  if (l > 0)
    str.assign(p, l);
  else
    str.clear();
  return l;
}
inline int AutoBuff_LoadStringA(HINSTANCE h, UINT i, std::string& str) {
  std::wstring wstr;
  int l = AutoBuff_LoadStringW(h, i, wstr);
  if (l <= 0) {
    str.clear();
    return 0;
  }

  int needed =
      WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), l, NULL, 0, NULL, NULL);
  if (needed <= 0) {
    str.clear();
    return 0;
  }

  str.resize(needed);
  int written = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), l, &str[0], needed,
                                    NULL, NULL);
  str.resize(written);
  return written;
}

inline int AutoBuff_GetClassNameA(HWND h, std::string& str) {
  char b[256];
  int r = GetClassNameA(h, b, 256);
  if (r > 0) str = b;
  return r;
}
inline int AutoBuff_GetClassNameW(HWND h, std::wstring& str) {
  wchar_t b[256];
  int r = GetClassNameW(h, b, 256);
  if (r > 0) str = b;
  return r;
}

inline int AutoBuff_GetDateFormatA(LCID l, DWORD f, const SYSTEMTIME* t,
                                   LPCSTR m, std::string& str) {
  int s = GetDateFormatA(l, f, t, m, NULL, 0);
  if (s <= 0) {
    str.clear();
    return 0;
  }
  str.resize(s - 1);
  return GetDateFormatA(l, f, t, m, &str[0], s);
}
inline int AutoBuff_GetDateFormatW(LCID l, DWORD f, const SYSTEMTIME* t,
                                   LPCWSTR m, std::wstring& str) {
  int s = GetDateFormatW(l, f, t, m, NULL, 0);
  if (s <= 0) {
    str.clear();
    return 0;
  }
  str.resize(s - 1);
  return GetDateFormatW(l, f, t, m, &str[0], s);
}

inline int AutoBuff_GetTimeFormatA(LCID l, DWORD f, const SYSTEMTIME* t,
                                   LPCSTR m, std::string& str) {
  int s = GetTimeFormatA(l, f, t, m, NULL, 0);
  if (s <= 0) {
    str.clear();
    return 0;
  }
  str.resize(s - 1);
  return GetTimeFormatA(l, f, t, m, &str[0], s);
}
inline int AutoBuff_GetTimeFormatW(LCID l, DWORD f, const SYSTEMTIME* t,
                                   LPCWSTR m, std::wstring& str) {
  int s = GetTimeFormatW(l, f, t, m, NULL, 0);
  if (s <= 0) {
    str.clear();
    return 0;
  }
  str.resize(s - 1);
  return GetTimeFormatW(l, f, t, m, &str[0], s);
}

inline int AutoBuff_GetNumberFormatA(LCID l, DWORD f, LPCSTR v,
                                     const NUMBERFMTA* fmt, std::string& str) {
  int s = GetNumberFormatA(l, f, v, fmt, NULL, 0);
  if (s <= 0) {
    str.clear();
    return 0;
  }
  str.resize(s - 1);
  return GetNumberFormatA(l, f, v, fmt, &str[0], s);
}
inline int AutoBuff_GetNumberFormatW(LCID l, DWORD f, LPCWSTR v,
                                     const NUMBERFMTW* fmt, std::wstring& str) {
  int s = GetNumberFormatW(l, f, v, fmt, NULL, 0);
  if (s <= 0) {
    str.clear();
    return 0;
  }
  str.resize(s - 1);
  return GetNumberFormatW(l, f, v, fmt, &str[0], s);
}

inline BOOL AutoBuff_GetFileVersionInfoA(LPCSTR f, std::vector<BYTE>& d) {
  DWORD h;
  DWORD s = GetFileVersionInfoSizeA(f, &h);
  if (s == 0) return FALSE;
  d.resize(s);
  return GetFileVersionInfoA(f, h, s, d.data());
}
inline BOOL AutoBuff_GetFileVersionInfoW(LPCWSTR f, std::vector<BYTE>& d) {
  DWORD h;
  DWORD s = GetFileVersionInfoSizeW(f, &h);
  if (s == 0) return FALSE;
  d.resize(s);
  return GetFileVersionInfoW(f, h, s, d.data());
}

inline std::string AutoBuff_wsprintfA(LPCSTR f, ...) {
  char b[1024];
  va_list a;
  va_start(a, f);
  wvsprintfA(b, f, a);
  va_end(a);
  return std::string(b);
}
inline std::wstring AutoBuff_wsprintfW(LPCWSTR f, ...) {
  wchar_t b[1024];
  va_list a;
  va_start(a, f);
  wvsprintfW(b, f, a);
  va_end(a);
  return std::wstring(b);
}

inline LSTATUS AutoBuff_RegQueryValueExA(HKEY hKey, LPCSTR lpValueName,
                                         LPDWORD lpType,
                                         std::vector<BYTE>& data) {
  DWORD size = 0;
  LSTATUS status = RegQueryValueExA(hKey, lpValueName, NULL, NULL, NULL, &size);
  if (status == ERROR_SUCCESS || status == ERROR_MORE_DATA) {
    data.resize(size);
    status =
        RegQueryValueExA(hKey, lpValueName, NULL, lpType, data.data(), &size);
    if (status == ERROR_SUCCESS) data.resize(size);
  }
  return status;
}
inline LSTATUS AutoBuff_RegQueryValueExW(HKEY hKey, LPCWSTR lpValueName,
                                         LPDWORD lpType,
                                         std::vector<BYTE>& data) {
  DWORD size = 0;
  LSTATUS status = RegQueryValueExW(hKey, lpValueName, NULL, NULL, NULL, &size);
  if (status == ERROR_SUCCESS || status == ERROR_MORE_DATA) {
    data.resize(size);
    status =
        RegQueryValueExW(hKey, lpValueName, NULL, lpType, data.data(), &size);
    if (status == ERROR_SUCCESS) data.resize(size);
  }
  return status;
}

inline LSTATUS AutoBuff_RegQueryStringA(HKEY hKey, LPCSTR lpValueName,
                                        std::string& str) {
  DWORD size = 0;
  LSTATUS status = RegQueryValueExA(hKey, lpValueName, NULL, NULL, NULL, &size);
  if (status == ERROR_SUCCESS || status == ERROR_MORE_DATA) {
    str.resize(size > 0 ? size - 1 : 0);
    status = RegQueryValueExA(hKey, lpValueName, NULL, NULL,
                              reinterpret_cast<LPBYTE>(&str[0]), &size);
  }
  return status;
}
inline LSTATUS AutoBuff_RegQueryStringW(HKEY hKey, LPCWSTR lpValueName,
                                        std::wstring& str) {
  DWORD size = 0;
  LSTATUS status = RegQueryValueExW(hKey, lpValueName, NULL, NULL, NULL, &size);
  if (status == ERROR_SUCCESS || status == ERROR_MORE_DATA) {
    str.resize(size / sizeof(wchar_t) - (size > 0 ? 1 : 0));
    status = RegQueryValueExW(hKey, lpValueName, NULL, NULL,
                              reinterpret_cast<LPBYTE>(&str[0]), &size);
  }
  return status;
}

inline LSTATUS AutoBuff_RegEnumValueA(HKEY hKey, DWORD dwIndex,
                                      std::string& strValueName, LPDWORD lpType,
                                      std::vector<BYTE>& data) {
  DWORD nSize = 1, dSize = 0;
  char dummy[1] = "";
  LSTATUS status =
      RegEnumValueA(hKey, dwIndex, dummy, &nSize, NULL, NULL, NULL, &dSize);
  if (status == ERROR_SUCCESS || status == ERROR_MORE_DATA) {
    strValueName.resize(nSize);
    data.resize(dSize);
    DWORD nSizeBuf = nSize + 1;
    status = RegEnumValueA(hKey, dwIndex, &strValueName[0], &nSizeBuf, NULL,
                           lpType, data.data(), &dSize);
    if (status == ERROR_SUCCESS) {
      strValueName.resize(nSizeBuf);
      data.resize(dSize);
    }
  }
  return status;
}
inline LSTATUS AutoBuff_RegEnumValueW(HKEY hKey, DWORD dwIndex,
                                      std::wstring& strValueName,
                                      LPDWORD lpType, std::vector<BYTE>& data) {
  DWORD nSize = 1, dSize = 0;
  WCHAR dummy[1] = L"";
  LSTATUS status =
      RegEnumValueW(hKey, dwIndex, dummy, &nSize, NULL, NULL, NULL, &dSize);
  if (status == ERROR_SUCCESS || status == ERROR_MORE_DATA) {
    strValueName.resize(nSize);
    data.resize(dSize);
    DWORD nSizeBuf = nSize + 1;
    status = RegEnumValueW(hKey, dwIndex, &strValueName[0], &nSizeBuf, NULL,
                           lpType, data.data(), &dSize);
    if (status == ERROR_SUCCESS) {
      strValueName.resize(nSizeBuf);
      data.resize(dSize);
    }
  }
  return status;
}

inline LSTATUS AutoBuff_RegQueryValueA(HKEY hKey, LPCSTR lpSubKey,
                                       std::string& str) {
  LONG size = 0;
  LSTATUS status = RegQueryValueA(hKey, lpSubKey, NULL, &size);
  if (status == ERROR_SUCCESS || status == ERROR_MORE_DATA) {
    str.resize(size > 0 ? size - 1 : 0);
    status = RegQueryValueA(hKey, lpSubKey, &str[0], &size);
  }
  return status;
}
inline LSTATUS AutoBuff_RegQueryValueW(HKEY hKey, LPCWSTR lpSubKey,
                                       std::wstring& str) {
  LONG size = 0;
  LSTATUS status = RegQueryValueW(hKey, lpSubKey, NULL, &size);
  if (status == ERROR_SUCCESS || status == ERROR_MORE_DATA) {
    str.resize(size > 0 ? (size / sizeof(wchar_t)) - 1 : 0);
    status = RegQueryValueW(hKey, lpSubKey, &str[0], &size);
  }
  return status;
}

inline LSTATUS AutoBuff_RegEnumKeyA(HKEY hKey, DWORD dwIndex,
                                    std::string& strName) {
  DWORD size = MAX_PATH;
  while (true) {
    strName.resize(size);
    // cchName includes null terminator, so pass size+1
    LSTATUS status = RegEnumKeyA(hKey, dwIndex, &strName[0], size + 1);
    if (status == ERROR_SUCCESS) {
      strName.resize(strlen(strName.c_str()));
      return status;
    }
    if (status != ERROR_MORE_DATA) {
      strName.clear();
      return status;
    }
    size *= 2;
    if (size > AUTOBUFF_MAX) {
      strName.clear();
      return status;
    }
  }
}
inline LSTATUS AutoBuff_RegEnumKeyW(HKEY hKey, DWORD dwIndex,
                                    std::wstring& strName) {
  DWORD size = MAX_PATH;
  while (true) {
    strName.resize(size);
    LSTATUS status = RegEnumKeyW(hKey, dwIndex, &strName[0], size + 1);
    if (status == ERROR_SUCCESS) {
      strName.resize(wcslen(strName.c_str()));
      return status;
    }
    if (status != ERROR_MORE_DATA) {
      strName.clear();
      return status;
    }
    size *= 2;
    if (size > AUTOBUFF_MAX) {
      strName.clear();
      return status;
    }
  }
}

inline LSTATUS AutoBuff_RegEnumKeyExA(HKEY hKey, DWORD dwIndex,
                                      std::string& strName,
                                      std::string* pstrClass = nullptr,
                                      PFILETIME lpft = nullptr) {
  DWORD nSize = 1, cSize = 0;
  char nDummy[1] = "", cDummy[1] = "";
  LSTATUS status =
      RegEnumKeyExA(hKey, dwIndex, nDummy, &nSize, NULL,
                    pstrClass ? cDummy : NULL, pstrClass ? &cSize : NULL, lpft);
  if (status == ERROR_SUCCESS || status == ERROR_MORE_DATA) {
    strName.resize(nSize);
    DWORD nBuf = nSize + 1;
    DWORD cBuf = cSize + 1;
    if (pstrClass) pstrClass->resize(cSize);
    status = RegEnumKeyExA(hKey, dwIndex, &strName[0], &nBuf, NULL,
                           pstrClass ? &(*pstrClass)[0] : NULL,
                           pstrClass ? &cBuf : NULL, lpft);
    if (status == ERROR_SUCCESS) {
      strName.resize(nBuf);
      if (pstrClass) pstrClass->resize(cBuf);
    } else {
      strName.clear();
      if (pstrClass) pstrClass->clear();
    }
  }
  return status;
}
inline LSTATUS AutoBuff_RegEnumKeyExW(HKEY hKey, DWORD dwIndex,
                                      std::wstring& strName,
                                      std::wstring* pstrClass = nullptr,
                                      PFILETIME lpft = nullptr) {
  DWORD nSize = 1, cSize = 0;
  WCHAR nDummy[1] = L"", cDummy[1] = L"";
  LSTATUS status =
      RegEnumKeyExW(hKey, dwIndex, nDummy, &nSize, NULL,
                    pstrClass ? cDummy : NULL, pstrClass ? &cSize : NULL, lpft);
  if (status == ERROR_SUCCESS || status == ERROR_MORE_DATA) {
    strName.resize(nSize);
    DWORD nBuf = nSize + 1;
    DWORD cBuf = cSize + 1;
    if (pstrClass) pstrClass->resize(cSize);
    status = RegEnumKeyExW(hKey, dwIndex, &strName[0], &nBuf, NULL,
                           pstrClass ? &(*pstrClass)[0] : NULL,
                           pstrClass ? &cBuf : NULL, lpft);
    if (status == ERROR_SUCCESS) {
      strName.resize(nBuf);
      if (pstrClass) pstrClass->resize(cBuf);
    } else {
      strName.clear();
      if (pstrClass) pstrClass->clear();
    }
  }
  return status;
}

#ifdef UNICODE
#define AutoBuff_GetAtomName AutoBuff_GetAtomNameW
#define AutoBuff_GetComputerName AutoBuff_GetComputerNameW
#define AutoBuff_GetComputerNameEx AutoBuff_GetComputerNameExW
#define AutoBuff_GetCurrentDirectory AutoBuff_GetCurrentDirectoryW
#define AutoBuff_GetEnvironmentVariable AutoBuff_GetEnvironmentVariableW
#define AutoBuff_GetFullPathName AutoBuff_GetFullPathNameW
#define AutoBuff_GetLogicalDriveStrings AutoBuff_GetLogicalDriveStringsW
#define AutoBuff_GetLongPathName AutoBuff_GetLongPathNameW
#define AutoBuff_GetShortPathName AutoBuff_GetShortPathNameW
#define AutoBuff_GetModuleFileName AutoBuff_GetModuleFileNameW
#define AutoBuff_GetPrivateProfileString AutoBuff_GetPrivateProfileStringW
#define AutoBuff_GetPrivateProfileSection AutoBuff_GetPrivateProfileSectionW
#define AutoBuff_GetPrivateProfileSectionNames \
  AutoBuff_GetPrivateProfileSectionNamesW
#define AutoBuff_GetSystemDirectory AutoBuff_GetSystemDirectoryW
#define AutoBuff_GetWindowsDirectory AutoBuff_GetWindowsDirectoryW
#define AutoBuff_GetSystemWindowsDirectory AutoBuff_GetSystemWindowsDirectoryW
#define AutoBuff_GetTempPath AutoBuff_GetTempPathW
#define AutoBuff_GetUserName AutoBuff_GetUserNameW
#define AutoBuff_GetConsoleTitle AutoBuff_GetConsoleTitleW
#define AutoBuff_GetWindowText AutoBuff_GetWindowTextW
#define AutoBuff_GetDlgItemText AutoBuff_GetDlgItemTextW
#define AutoBuff_LoadString AutoBuff_LoadStringW
#define AutoBuff_GetClassName AutoBuff_GetClassNameW
#define AutoBuff_GetDateFormat AutoBuff_GetDateFormatW
#define AutoBuff_GetTimeFormat AutoBuff_GetTimeFormatW
#define AutoBuff_GetNumberFormat AutoBuff_GetNumberFormatW
#define AutoBuff_GetFileVersionInfo AutoBuff_GetFileVersionInfoW
#define AutoBuff_wsprintf AutoBuff_wsprintfW
#define AutoBuff_RegQueryValueEx AutoBuff_RegQueryValueExW
#define AutoBuff_RegQueryString AutoBuff_RegQueryStringW
#define AutoBuff_RegEnumValue AutoBuff_RegEnumValueW
#define AutoBuff_RegQueryValue AutoBuff_RegQueryValueW
#define AutoBuff_RegEnumKey AutoBuff_RegEnumKeyW
#define AutoBuff_RegEnumKeyEx AutoBuff_RegEnumKeyExW
#else
#define AutoBuff_GetAtomName AutoBuff_GetAtomNameA
#define AutoBuff_GetComputerName AutoBuff_GetComputerNameA
#define AutoBuff_GetComputerNameEx AutoBuff_GetComputerNameExA
#define AutoBuff_GetCurrentDirectory AutoBuff_GetCurrentDirectoryA
#define AutoBuff_GetEnvironmentVariable AutoBuff_GetEnvironmentVariableA
#define AutoBuff_GetFullPathName AutoBuff_GetFullPathNameA
#define AutoBuff_GetLogicalDriveStrings AutoBuff_GetLogicalDriveStringsA
#define AutoBuff_GetLongPathName AutoBuff_GetLongPathNameA
#define AutoBuff_GetShortPathName AutoBuff_GetShortPathNameA
#define AutoBuff_GetModuleFileName AutoBuff_GetModuleFileNameA
#define AutoBuff_GetPrivateProfileString AutoBuff_GetPrivateProfileStringA
#define AutoBuff_GetPrivateProfileSection AutoBuff_GetPrivateProfileSectionA
#define AutoBuff_GetPrivateProfileSectionNames \
  AutoBuff_GetPrivateProfileSectionNamesA
#define AutoBuff_GetSystemDirectory AutoBuff_GetSystemDirectoryA
#define AutoBuff_GetWindowsDirectory AutoBuff_GetWindowsDirectoryA
#define AutoBuff_GetSystemWindowsDirectory AutoBuff_GetSystemWindowsDirectoryA
#define AutoBuff_GetTempPath AutoBuff_GetTempPathA
#define AutoBuff_GetUserName AutoBuff_GetUserNameA
#define AutoBuff_GetConsoleTitle AutoBuff_GetConsoleTitleA
#define AutoBuff_GetWindowText AutoBuff_GetWindowTextA
#define AutoBuff_GetDlgItemText AutoBuff_GetDlgItemTextA
#define AutoBuff_LoadString AutoBuff_LoadStringA
#define AutoBuff_GetClassName AutoBuff_GetClassNameA
#define AutoBuff_GetDateFormat AutoBuff_GetDateFormatA
#define AutoBuff_GetTimeFormat AutoBuff_GetTimeFormatA
#define AutoBuff_GetNumberFormat AutoBuff_GetNumberFormatA
#define AutoBuff_GetFileVersionInfo AutoBuff_GetFileVersionInfoA
#define AutoBuff_wsprintf AutoBuff_wsprintfA
#define AutoBuff_RegQueryValueEx AutoBuff_RegQueryValueExA
#define AutoBuff_RegQueryString AutoBuff_RegQueryStringA
#define AutoBuff_RegEnumValue AutoBuff_RegEnumValueA
#define AutoBuff_RegQueryValue AutoBuff_RegQueryValueA
#define AutoBuff_RegEnumKey AutoBuff_RegEnumKeyA
#define AutoBuff_RegEnumKeyEx AutoBuff_RegEnumKeyExA
#endif