Support for building V8 with MinGW

src/platform-win32.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 40 matching lines @@
 // Require Windows 2000 or higher (this is required for the IsDebuggerPresent
 // function to be present).
 #ifndef _WIN32_WINNT
 #define _WIN32_WINNT 0x500
 #endif
 
 #include <windows.h>
 
 #include <time.h>  // For LocalOffset() implementation.
 #include <mmsystem.h>  // For timeGetTime().
+#ifndef __MINGW32__
 #include <dbghelp.h>  // For SymLoadModule64 and al.
+#endif  // __MINGW32__
+#include <limits.h>  // For INT_MAX and al.
 #include <tlhelp32.h>  // For Module32First and al.
 
 // These additional WIN32 includes have to be right here as the #undef's below
 // makes it impossible to have them elsewhere.
 #include <winsock2.h>
 #include <process.h>  // for _beginthreadex()
 #include <stdlib.h>
 
-#pragma comment(lib, "winmm.lib")  // force linkage with winmm.
-
 #undef VOID
 #undef DELETE
 #undef IN
 #undef THIS
 #undef CONST
 #undef NAN
 #undef GetObject
 #undef CreateMutex
 #undef CreateSemaphore
 
 #include "v8.h"
 
 #include "platform.h"
 
-// Extra POSIX/ANSI routines for Win32. Please refer to The Open Group Base
-// Specification for specification of the correct semantics for these
-// functions.
+// Extra POSIX/ANSI routines for Win32 when when using Visual Studio C++. Please
+// refer to The Open Group Base Specification for specification of the correct
+// semantics for these functions.
 // (http://www.opengroup.org/onlinepubs/000095399/)
+#ifdef _MSC_VER
 
-// Test for finite value - usually defined in math.h
 namespace v8 {
 namespace internal {
 
+// Test for finite value - usually defined in math.h
 int isfinite(double x) {
   return _finite(x);
 }
 
 }  // namespace v8
 }  // namespace internal
 
 // Test for a NaN (not a number) value - usually defined in math.h
 int isnan(double x) {
   return _isnan(x);
@@ skipping 40 matching lines @@
 int signbit(double x) {
   // We need to take care of the special case of both positive
   // and negative versions of zero.
   if (x == 0)
     return _fpclass(x) & _FPCLASS_NZ;
   else
     return x < 0;
 }
 
 
-// Generate a pseudo-random number in the range 0-2^31-1. Usually
-// defined in stdlib.h
-int random() {
-  return rand();
-}
-
-
 // Case-insensitive bounded string comparisons. Use stricmp() on Win32. Usually
 // defined in strings.h.
 int strncasecmp(const char* s1, const char* s2, int n) {
   return _strnicmp(s1, s2, n);
 }
 
+#endif  // _MSC_VER
+
+
+// Extra functions for MinGW. Most of these are the _s functions which are in
+// the Microsoft Visual Studio C++ CRT.
+#ifdef __MINGW32__
+
+int localtime_s(tm* out_tm, const time_t* time) {
+  tm* posix_local_time_struct = localtime(time);
+  if (posix_local_time_struct == NULL) return 1;
+  *out_tm = *posix_local_time_struct;
+  return 0;
+}
+
+
+// Not sure this the correct interpretation of _mkgmtime
+time_t _mkgmtime(tm* timeptr) {
+  return mktime(timeptr);
+}
+
+
+int fopen_s(FILE** pFile, const char* filename, const char* mode) {
+  *pFile = fopen(filename, mode);
+  return *pFile != NULL ? 0 : 1;
+}
+
+
+int _vsnprintf_s(char* buffer, size_t sizeOfBuffer, size_t count,
+                 const char* format, va_list argptr) {
+  return _vsnprintf(buffer, sizeOfBuffer, format, argptr);
+}
+#define _TRUNCATE 0
+
+
+int strncpy_s(char* strDest, size_t numberOfElements,
+              const char* strSource, size_t count) {
+  strncpy(strDest, strSource, count);
+  return 0;
+}
+
+#endif  // __MINGW32__
+
+// Generate a pseudo-random number in the range 0-2^31-1. Usually
+// defined in stdlib.h. Missing in both Microsoft Visual Studio C++ and MinGW.
+int random() {
+  return rand();
+}
+
+
 namespace v8 { namespace internal {
 
 double ceiling(double x) {
   return ceil(x);
 }
 
 // ----------------------------------------------------------------------------
 // The Time class represents time on win32. A timestamp is represented as
 // a 64-bit integer in 100 nano-seconds since January 1, 1601 (UTC). JavaScript
 // timestamps are represented as a doubles in milliseconds since 00:00:00 UTC,
@@ skipping 21 matching lines @@
 
   // Returns the daylight savings time offset for the time in milliseconds.
   int64_t DaylightSavingsOffset();
 
   // Returns a string identifying the current timezone for the
   // timestamp taking into account daylight saving.
   char* LocalTimezone();
 
  private:
   // Constants for time conversion.
-  static const int64_t kTimeEpoc = 116444736000000000;
+  static const int64_t kTimeEpoc = 116444736000000000LL;
   static const int64_t kTimeScaler = 10000;
   static const int64_t kMsPerMinute = 60000;
 
   // Constants for timezone information.
   static const int kTzNameSize = 128;
   static const bool kShortTzNames = false;
 
   // Timezone information. We need to have static buffers for the
   // timezone names because we return pointers to these in
   // LocalTimezone().
@@ skipping 580 matching lines @@
 }
 
 
 void OS::Sleep(int milliseconds) {
   ::Sleep(milliseconds);
 }
 
 
 void OS::Abort() {
   if (!IsDebuggerPresent()) {
+#ifdef _MSC_VER
     // Make the MSVCRT do a silent abort.
     _set_abort_behavior(0, _WRITE_ABORT_MSG);
     _set_abort_behavior(0, _CALL_REPORTFAULT);
+#endif  // _MSC_VER
     abort();
   } else {
     DebugBreak();
   }
 }
 
 
 void OS::DebugBreak() {
+#ifdef _MSC_VER
   __debugbreak();
+#else
+  ::DebugBreak();
+#endif
 }
 
 
 class Win32MemoryMappedFile : public OS::MemoryMappedFile {
  public:
   Win32MemoryMappedFile(HANDLE file, HANDLE file_mapping, void* memory)
     : file_(file), file_mapping_(file_mapping), memory_(memory) { }
   virtual ~Win32MemoryMappedFile();
   virtual void* memory() { return memory_; }
  private:
@@ skipping 62 matching lines @@
 // definitions are copied from DbgHelp.h and TlHelp32.h. The IN and VOID macros
 // from the Windows include files are redefined here to have the function
 // definitions to be as close to the ones in the original .h files as possible.
 #ifndef IN
 #define IN
 #endif
 #ifndef VOID
 #define VOID void
 #endif
 
+// DbgHelp isn't supported on MinGW yet
+#ifndef __MINGW32__
 // DbgHelp.h functions.
 typedef BOOL (__stdcall *DLL_FUNC_TYPE(SymInitialize))(IN HANDLE hProcess,
                                                        IN PSTR UserSearchPath,
                                                        IN BOOL fInvadeProcess);
 typedef DWORD (__stdcall *DLL_FUNC_TYPE(SymGetOptions))(VOID);
 typedef DWORD (__stdcall *DLL_FUNC_TYPE(SymSetOptions))(IN DWORD SymOptions);
 typedef BOOL (__stdcall *DLL_FUNC_TYPE(SymGetSearchPath))(
     IN HANDLE hProcess,
     OUT PSTR SearchPath,
     IN DWORD SearchPathLength);
@@ skipping 302 matching lines @@
     frames_count++;
   }
 
   // Return the number of frames filled in.
   return frames_count;
 }
 
 // Restore warnings to previous settings.
 #pragma warning(pop)
 
+#else  // __MINGW32__
+void OS::LogSharedLibraryAddresses() { }
+int OS::StackWalk(OS::StackFrame* frames, int frames_size) { return 0; }
+#endif  // __MINGW32__
+
 
 double OS::nan_value() {
+#ifdef _MSC_VER
   static const __int64 nanval = 0xfff8000000000000;
   return *reinterpret_cast<const double*>(&nanval);
+#else  // _MSC_VER
+  return NAN;
+#endif  // _MSC_VER
 }
 
 
 int OS::ActivationFrameAlignment() {
   // No constraint on Windows.
   return 0;
 }
 
 
 bool VirtualMemory::IsReserved() {
@@ skipping 20 matching lines @@
     return false;
   }
 
   UpdateAllocatedSpaceLimits(address, size);
   return true;
 }
 
 
 bool VirtualMemory::Uncommit(void* address, size_t size) {
   ASSERT(IsReserved());
-  return VirtualFree(address, size, MEM_DECOMMIT) != NULL;
+  return VirtualFree(address, size, MEM_DECOMMIT) != FALSE;
 }
 
 
 // ----------------------------------------------------------------------------
 // Win32 thread support.
 
 // Definition of invalid thread handle and id.
 static const HANDLE kNoThread = INVALID_HANDLE_VALUE;
 static const DWORD kNoThreadId = 0;
 
@@ skipping 314 matching lines @@
 
   // Release the thread handles
   CloseHandle(data_->sampler_thread_);
   CloseHandle(data_->profiled_thread_);
 }
 
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 } }  // namespace v8::internal