Move platform abstraction to base library

src/utils.cc

 // Copyright 2011 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.
 
 #include <stdarg.h>
 #include <sys/stat.h>
 
 #include "src/v8.h"
 
-#include "src/checks.h"
-#include "src/platform.h"
+#include "src/base/logging.h"
+#include "src/base/platform/platform.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 
 SimpleStringBuilder::SimpleStringBuilder(int size) {
   buffer_ = Vector<char>::New(size);
   position_ = 0;
 }
@@ skipping 51 matching lines @@
   ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_));
   position_ = -1;
   ASSERT(is_finalized());
   return buffer_.start();
 }
 
 
 void PrintF(const char* format, ...) {
   va_list arguments;
   va_start(arguments, format);
-  OS::VPrint(format, arguments);
+  base::OS::VPrint(format, arguments);
   va_end(arguments);
 }
 
 
 void PrintF(FILE* out, const char* format, ...) {
   va_list arguments;
   va_start(arguments, format);
-  OS::VFPrint(out, format, arguments);
+  base::OS::VFPrint(out, format, arguments);
   va_end(arguments);
 }
 
 
 void PrintPID(const char* format, ...) {
-  OS::Print("[%d] ", OS::GetCurrentProcessId());
+  base::OS::Print("[%d] ", base::OS::GetCurrentProcessId());
   va_list arguments;
   va_start(arguments, format);
-  OS::VPrint(format, arguments);
+  base::OS::VPrint(format, arguments);
   va_end(arguments);
 }
 
 
 int SNPrintF(Vector<char> str, const char* format, ...) {
   va_list args;
   va_start(args, format);
   int result = VSNPrintF(str, format, args);
   va_end(args);
   return result;
 }
 
 
 int VSNPrintF(Vector<char> str, const char* format, va_list args) {
-  return OS::VSNPrintF(str.start(), str.length(), format, args);
+  return base::OS::VSNPrintF(str.start(), str.length(), format, args);
 }
 
 
 void StrNCpy(Vector<char> dest, const char* src, size_t n) {
-  OS::StrNCpy(dest.start(), dest.length(), src, n);
+  base::OS::StrNCpy(dest.start(), dest.length(), src, n);
 }
 
 
 void Flush(FILE* out) {
   fflush(out);
 }
 
 
 char* ReadLine(const char* prompt) {
   char* result = NULL;
@@ skipping 47 matching lines @@
 }
 
 
 char* ReadCharsFromFile(FILE* file,
                         int* size,
                         int extra_space,
                         bool verbose,
                         const char* filename) {
   if (file == NULL || fseek(file, 0, SEEK_END) != 0) {
     if (verbose) {
-      OS::PrintError("Cannot read from file %s.\n", filename);
+      base::OS::PrintError("Cannot read from file %s.\n", filename);
     }
     return NULL;
   }
 
   // Get the size of the file and rewind it.
   *size = ftell(file);
   rewind(file);
 
   char* result = NewArray<char>(*size + extra_space);
   for (int i = 0; i < *size && feof(file) == 0;) {
     int read = static_cast<int>(fread(&result[i], 1, *size - i, file));
     if (read != (*size - i) && ferror(file) != 0) {
       fclose(file);
       DeleteArray(result);
       return NULL;
     }
     i += read;
   }
   return result;
 }
 
 
 char* ReadCharsFromFile(const char* filename,
                         int* size,
                         int extra_space,
                         bool verbose) {
-  FILE* file = OS::FOpen(filename, "rb");
+  FILE* file = base::OS::FOpen(filename, "rb");
   char* result = ReadCharsFromFile(file, size, extra_space, verbose, filename);
   if (file != NULL) fclose(file);
   return result;
 }
 
 
 byte* ReadBytes(const char* filename, int* size, bool verbose) {
   char* chars = ReadCharsFromFile(filename, size, 0, verbose);
   return reinterpret_cast<byte*>(chars);
 }
@@ skipping 41 matching lines @@
     str += write;
   }
   return total;
 }
 
 
 int AppendChars(const char* filename,
                 const char* str,
                 int size,
                 bool verbose) {
-  FILE* f = OS::FOpen(filename, "ab");
+  FILE* f = base::OS::FOpen(filename, "ab");
   if (f == NULL) {
     if (verbose) {
-      OS::PrintError("Cannot open file %s for writing.\n", filename);
+      base::OS::PrintError("Cannot open file %s for writing.\n", filename);
     }
     return 0;
   }
   int written = WriteCharsToFile(str, size, f);
   fclose(f);
   return written;
 }
 
 
 int WriteChars(const char* filename,
                const char* str,
                int size,
                bool verbose) {
-  FILE* f = OS::FOpen(filename, "wb");
+  FILE* f = base::OS::FOpen(filename, "wb");
   if (f == NULL) {
     if (verbose) {
-      OS::PrintError("Cannot open file %s for writing.\n", filename);
+      base::OS::PrintError("Cannot open file %s for writing.\n", filename);
     }
     return 0;
   }
   int written = WriteCharsToFile(str, size, f);
   fclose(f);
   return written;
 }
 
 
 int WriteBytes(const char* filename,
@@ skipping 100 matching lines @@
   }
   if (u.bits.exp == 0) {
     // Detect +0, and -0 for IEEE double precision floating point.
     if ((u.bits.man_low | u.bits.man_high) == 0) return false;
   }
   return true;
 }
 
 
 } }  // namespace v8::internal