Make it compile with Visual Studio 2013.

include/benchmark/macros.h

@@ -27,12 +27,16 @@
 #if defined(__GNUC__)
 # define BENCHMARK_UNUSED __attribute__((unused))
 # define BENCHMARK_ALWAYS_INLINE __attribute__((always_inline))
+# define BENCHMARK_NOEXCEPT noexcept
 #elif defined(_MSC_VER) && !defined(__clang__)
 # define BENCHMARK_UNUSED
 # define BENCHMARK_ALWAYS_INLINE __forceinline
+# define BENCHMARK_NOEXCEPT
+# define __func__ __FUNCTION__
 #else
 # define BENCHMARK_UNUSED
 # define BENCHMARK_ALWAYS_INLINE
+# define BENCHMARK_NOEXCEPT
 #endif
 
 #if defined(__GNUC__)

src/benchmark.cc

@@ -15,11 +15,11 @@
 #include "benchmark/benchmark.h"
 #include "internal_macros.h"
 
-#include <sys/time.h>
 #ifndef OS_WINDOWS
+#include <sys/time.h>
 #include <sys/resource.h>
-#endif
 #include <unistd.h>
+#endif
 
 #include <cstdlib>
 #include <cstring>

src/cycleclock.h

@@ -40,7 +40,10 @@
 extern "C" uint64_t __rdtsc();
 #pragma intrinsic(__rdtsc)
 #endif
+
+#if !defined(OS_WINDOWS)
 #include <sys/time.h>
+#endif
 
 namespace benchmark {
 // NOTE: only i386 and x86_64 have been well tested.

src/string_util.h

@@ -4,6 +4,7 @@
 #include <string>
 #include <sstream>
 #include <utility>
+#include "internal_macros.h"
 
 namespace benchmark {
 
@@ -14,7 +15,7 @@ std::string HumanReadableNumber(double n);
 std::string StringPrintF(const char* format, ...);
 
 inline std::ostream&
-StringCatImp(std::ostream& out) noexcept
+StringCatImp(std::ostream& out) BENCHMARK_NOEXCEPT
 {
   return out;
 }

src/walltime.cc

@@ -13,8 +13,15 @@
 // limitations under the License.
 
 #include "walltime.h"
+#include "benchmark/macros.h"
+#include "internal_macros.h"
 
+#if defined(OS_WINDOWS)
+#include <time.h>
+#include <winsock.h> // for timeval
+#else
 #include <sys/time.h>
+#endif
 
 #include <cstdio>
 #include <cstdint>
@@ -92,7 +99,22 @@ private:
 
   WallTime Slow() const {
     struct timeval tv;
+#if defined(OS_WINDOWS)
+    FILETIME    file_time;
+    SYSTEMTIME  system_time;
+    ULARGE_INTEGER ularge;
+    const unsigned __int64 epoch = 116444736000000000LL;
+
+    GetSystemTime(&system_time);
+    SystemTimeToFileTime(&system_time, &file_time);
+    ularge.LowPart = file_time.dwLowDateTime;
+    ularge.HighPart = file_time.dwHighDateTime;
+
+    tv.tv_sec = (long)((ularge.QuadPart - epoch) / 10000000L);
+    tv.tv_usec = (long)(system_time.wMilliseconds * 1000);
+#else
     gettimeofday(&tv, nullptr);
+#endif
     return tv.tv_sec + tv.tv_usec * 1e-6;
   }
 
@@ -100,8 +122,6 @@ private:
   static_assert(sizeof(float) <= sizeof(int32_t),
                "type sizes don't allow the drift_adjust hack");
 
-  static constexpr double kMaxErrorInterval = 100e-6;
-
   WallTime base_walltime_;
   int64_t base_cycletime_;
   int64_t cycles_per_second_;
@@ -147,7 +167,8 @@ WallTimeImp::WallTimeImp()
       cycles_per_second_(0), seconds_per_cycle_(0.0),
       last_adjust_time_(0), drift_adjust_(0),
       max_interval_cycles_(0) {
-  cycles_per_second_ = static_cast<int64_t>(CyclesPerSecond());
+    const double kMaxErrorInterval = 100e-6;
+    cycles_per_second_ = static_cast<int64_t>(CyclesPerSecond());
   CHECK(cycles_per_second_ != 0);
   seconds_per_cycle_ = 1.0 / cycles_per_second_;
   max_interval_cycles_ =
@@ -213,15 +234,27 @@ std::string DateTimeString(bool local) {
   typedef std::chrono::system_clock Clock;
   std::time_t now = Clock::to_time_t(Clock::now());
   char storage[128];
+  std::size_t written;
 
-  std::tm timeinfo;
-  std::memset(&timeinfo, 0, sizeof(std::tm));
   if (local) {
-    localtime_r(&now, &timeinfo);
+#if defined(OS_WINDOWS)
+    written = std::strftime(storage, sizeof(storage), "%x %X", ::localtime(&now));
+#else
+    std::tm timeinfo;
+    std::memset(&timeinfo, 0, sizeof(std::tm));
+    ::localtime_r(&now, &timeinfo);
+    written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
+#endif
   } else {
-    gmtime_r(&now, &timeinfo);
+#if defined(OS_WINDOWS)
+    written = std::strftime(storage, sizeof(storage), "%x %X", ::gmtime(&now));
+#else
+    std::tm timeinfo;
+    std::memset(&timeinfo, 0, sizeof(std::tm));
+    ::gmtime_r(&now, &timeinfo);
+    written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
+#endif
   }
-  std::size_t written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
   CHECK(written < arraysize(storage));
   ((void)written); // prevent unused variable in optimized mode.
   return std::string(storage);