Remove dependency on Vector from platform files

src/platform-win32.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Platform-specific code for Win32.
 
 // Secure API functions are not available using MinGW with msvcrt.dll
 // on Windows XP. Make sure MINGW_HAS_SECURE_API is not defined to
 // disable definition of secure API functions in standard headers that
 // would conflict with our own implementation.
@@ skipping 133 matching lines @@
     std_tz_name_[kTzNameSize - 1] = '\0';
     WideCharToMultiByte(CP_UTF8, 0, tzinfo_.DaylightName, -1,
                         dst_tz_name_, kTzNameSize, NULL, NULL);
     dst_tz_name_[kTzNameSize - 1] = '\0';
 
     // If OS returned empty string or resource id (like "@tzres.dll,-211")
     // simply guess the name from the UTC bias of the timezone.
     // To properly resolve the resource identifier requires a library load,
     // which is not possible in a sandbox.
     if (std_tz_name_[0] == '\0' || std_tz_name_[0] == '@') {
-      OS::SNPrintF(Vector<char>(std_tz_name_, kTzNameSize - 1),
+      OS::SNPrintF(std_tz_name_, kTzNameSize - 1,
                    "%s Standard Time",
                    GuessTimezoneNameFromBias(tzinfo_.Bias));
     }
     if (dst_tz_name_[0] == '\0' || dst_tz_name_[0] == '@') {
-      OS::SNPrintF(Vector<char>(dst_tz_name_, kTzNameSize - 1),
+      OS::SNPrintF(dst_tz_name_, kTzNameSize - 1,
                    "%s Daylight Time",
                    GuessTimezoneNameFromBias(tzinfo_.Bias));
     }
     // Timezone information initialized.
     initialized_ = true;
   }
 
   // Guess the name of the timezone from the bias.
   // The guess is very biased towards the northern hemisphere.
   const char* GuessTimezoneNameFromBias(int bias) {
@@ skipping 374 matching lines @@
   }
   return output_mode == CONSOLE;
 }
 
 
 static void VPrintHelper(FILE* stream, const char* format, va_list args) {
   if ((stream == stdout || stream == stderr) && !HasConsole()) {
     // It is important to use safe print here in order to avoid
     // overflowing the buffer. We might truncate the output, but this
     // does not crash.
-    EmbeddedVector<char, 4096> buffer;
-    OS::VSNPrintF(buffer, format, args);
-    OutputDebugStringA(buffer.start());
+    char buffer[4096];
+    OS::VSNPrintF(buffer, sizeof(buffer), format, args);
+    OutputDebugStringA(buffer);
   } else {
     vfprintf(stream, format, args);
   }
 }
 
 
 FILE* OS::FOpen(const char* path, const char* mode) {
   FILE* result;
   if (fopen_s(&result, path, mode) == 0) {
     return result;
@@ skipping 64 matching lines @@
   VPrintError(format, args);
   va_end(args);
 }
 
 
 void OS::VPrintError(const char* format, va_list args) {
   VPrintHelper(stderr, format, args);
 }
 
 
-int OS::SNPrintF(Vector<char> str, const char* format, ...) {
+int OS::SNPrintF(char* str, int length, const char* format, ...) {
   va_list args;
   va_start(args, format);
-  int result = VSNPrintF(str, format, args);
+  int result = VSNPrintF(str, length, format, args);
   va_end(args);
   return result;
 }
 
 
-int OS::VSNPrintF(Vector<char> str, const char* format, va_list args) {
-  int n = _vsnprintf_s(str.start(), str.length(), _TRUNCATE, format, args);
+int OS::VSNPrintF(char* str, int length, const char* format, va_list args) {
+  int n = _vsnprintf_s(str, length, _TRUNCATE, format, args);
   // Make sure to zero-terminate the string if the output was
   // truncated or if there was an error.
-  if (n < 0 || n >= str.length()) {
-    if (str.length() > 0)
-      str[str.length() - 1] = '\0';
+  if (n < 0 || n >= length) {
+    if (length > 0)
+      str[length - 1] = '\0';
     return -1;
   } else {
     return n;
   }
 }
 
 
 char* OS::StrChr(char* str, int c) {
   return const_cast<char*>(strchr(str, c));
 }
 
 
-void OS::StrNCpy(Vector<char> dest, const char* src, size_t n) {
+void OS::StrNCpy(char* dest, int length, const char* src, size_t n) {
   // Use _TRUNCATE or strncpy_s crashes (by design) if buffer is too small.
-  size_t buffer_size = static_cast<size_t>(dest.length());
+  size_t buffer_size = static_cast<size_t>(length);
   if (n + 1 > buffer_size)  // count for trailing '\0'
     n = _TRUNCATE;
-  int result = strncpy_s(dest.start(), dest.length(), src, n);
+  int result = strncpy_s(dest, length, src, n);
   USE(result);
   ASSERT(result == 0 || (n == _TRUNCATE && result == STRUNCATE));
 }
 
 
 #undef _TRUNCATE
 #undef STRUNCATE
 
 
 // Get the system's page size used by VirtualAlloc() or the next power
@@ skipping 650 matching lines @@
 
 Thread::Thread(const Options& options)
     : stack_size_(options.stack_size()),
       start_semaphore_(NULL) {
   data_ = new PlatformData(kNoThread);
   set_name(options.name());
 }
 
 
 void Thread::set_name(const char* name) {
-  OS::StrNCpy(Vector<char>(name_, sizeof(name_)), name, strlen(name));
+  OS::StrNCpy(name_, sizeof(name_), name, strlen(name));
   name_[sizeof(name_) - 1] = '\0';
 }
 
 
 // Close our own handle for the thread.
 Thread::~Thread() {
   if (data_->thread_ != kNoThread) CloseHandle(data_->thread_);
   delete data_;
 }
 
@@ skipping 45 matching lines @@
   ASSERT(result);
 }
 
 
 
 void Thread::YieldCPU() {
   Sleep(0);
 }
 
 } }  // namespace v8::internal