Replaced calls to functions that msvc consider deprecated. Used...

src/utils.h

 // 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 261 matching lines @@
 
 
 template <typename T>
 class Vector {
  public:
   Vector() : start_(NULL), length_(0) {}
   Vector(T* data, int length) : start_(data), length_(length) {
     ASSERT(length == 0 || (length > 0 && data != NULL));
   }
 
+  static Vector<T> New(int length) {
+    return Vector<T>(NewArray<T>(length), length);
+  }
+
   // Returns the length of the vector.
   int length() const { return length_; }
 
   // Returns whether or not the vector is empty.
   bool is_empty() const { return length_ == 0; }
 
   // Returns the pointer to the start of the data in the vector.
   T* start() const { return start_; }
 
   // Access individual vector elements - checks bounds in debug mode.
@@ skipping 11 matching lines @@
 
   // Releases the array underlying this vector. Once disposed the
   // vector is empty.
   void Dispose() {
     if (is_empty()) return;
     DeleteArray(start_);
     start_ = NULL;
     length_ = 0;
   }
 
+  inline Vector<T> operator+(int offset) {
+    ASSERT(offset < length_);
+    return Vector<T>(start_ + offset, length_ - offset);
+  }
+
   // Factory method for creating empty vectors.
   static Vector<T> empty() { return Vector<T>(NULL, 0); }
 
  private:
   T* start_;
   int length_;
 };
 
 
+template <typename T, int size>
+class EmbeddedVector : public Vector<T> {
+ public:
+  EmbeddedVector() : Vector<T>(buffer_, size) { }
+ private:
+  T buffer_[size];
+};
+
+
 inline Vector<const char> CStrVector(const char* data) {
   return Vector<const char>(data, strlen(data));
 }
 
 inline Vector<char> MutableCStrVector(char* data) {
   return Vector<char>(data, strlen(data));
 }
 
+inline Vector<char> MutableCStrVector(char* data, int max) {
+  int length = strlen(data);
+  return Vector<char>(data, (length < max) ? length : max);
+}
+
 template <typename T>
 inline Vector< Handle<Object> > HandleVector(v8::internal::Handle<T>* elms,
                                              int length) {
   return Vector< Handle<Object> >(
       reinterpret_cast<v8::internal::Handle<Object>*>(elms), length);
 }
 
 
 // Simple support to read a file into a 0-terminated C-string.
 // The returned buffer must be freed by the caller.
@@ skipping 22 matching lines @@
 // purpose of the class is to use safe operations that checks the
 // buffer bounds on all operations in debug mode.
 class StringBuilder {
  public:
   // Create a string builder with a buffer of the given size. The
   // buffer is allocated through NewArray<char> and must be
   // deallocated by the caller of Finalize().
   explicit StringBuilder(int size);
 
   StringBuilder(char* buffer, int size)
-      : buffer_(buffer), size_(size), position_(0) { }
+      : buffer_(buffer, size), position_(0) { }
 
   ~StringBuilder() { if (!is_finalized()) Finalize(); }
 
-  int size() const { return size_; }
+  int size() const { return buffer_.length(); }
 
   // Get the current position in the builder.
   int position() const {
     ASSERT(!is_finalized());
     return position_;
   }
 
   // Reset the position.
   void Reset() { position_ = 0; }
 
   // Add a single character to the builder. It is not allowed to add
   // 0-characters; use the Finalize() method to terminate the string
   // instead.
   void AddCharacter(char c) {
     ASSERT(c != '\0');
-    ASSERT(!is_finalized() && position_ < size_);
+    ASSERT(!is_finalized() && position_ < buffer_.length());
     buffer_[position_++] = c;
   }
 
   // Add an entire string to the builder. Uses strlen() internally to
   // compute the length of the input string.
   void AddString(const char* s);
 
   // Add the first 'n' characters of the given string 's' to the
   // builder. The input string must have enough characters.
   void AddSubstring(const char* s, int n);
 
   // Add formatted contents to the builder just like printf().
   void AddFormatted(const char* format, ...);
 
   // Add character padding to the builder. If count is non-positive,
   // nothing is added to the builder.
   void AddPadding(char c, int count);
 
   // Finalize the string by 0-terminating it and returning the buffer.
   char* Finalize();
 
  private:
-  char* buffer_;
-  int size_;
+  Vector<char> buffer_;
   int position_;
 
   bool is_finalized() const { return position_ < 0; }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_UTILS_H_