Upgrade to 3.29
Update V8 to 3.29.88.17 and update makefiles to support building on
all the relevant platforms.
Bug: 17370214
Change-Id: Ia3407c157fd8d72a93e23d8318ccaf6ecf77fa4e
diff --git a/src/ostreams.cc b/src/ostreams.cc
new file mode 100644
index 0000000..e927e6b
--- /dev/null
+++ b/src/ostreams.cc
@@ -0,0 +1,189 @@
+// Copyright 2014 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 "src/ostreams.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "src/base/platform/platform.h" // For isinf/isnan with MSVC
+
+#if V8_OS_WIN
+#define snprintf sprintf_s
+#endif
+
+namespace v8 {
+namespace internal {
+
+// Be lazy and delegate the value=>char conversion to snprintf.
+template<class T>
+OStream& OStream::print(const char* format, T x) {
+ char buf[32];
+ int n = snprintf(buf, sizeof(buf), format, x);
+ return (n < 0) ? *this : write(buf, n);
+}
+
+
+OStream& OStream::operator<<(short x) { // NOLINT(runtime/int)
+ return print(hex_ ? "%hx" : "%hd", x);
+}
+
+
+OStream& OStream::operator<<(unsigned short x) { // NOLINT(runtime/int)
+ return print(hex_ ? "%hx" : "%hu", x);
+}
+
+
+OStream& OStream::operator<<(int x) {
+ return print(hex_ ? "%x" : "%d", x);
+}
+
+
+OStream& OStream::operator<<(unsigned int x) {
+ return print(hex_ ? "%x" : "%u", x);
+}
+
+
+OStream& OStream::operator<<(long x) { // NOLINT(runtime/int)
+ return print(hex_ ? "%lx" : "%ld", x);
+}
+
+
+OStream& OStream::operator<<(unsigned long x) { // NOLINT(runtime/int)
+ return print(hex_ ? "%lx" : "%lu", x);
+}
+
+
+OStream& OStream::operator<<(long long x) { // NOLINT(runtime/int)
+ return print(hex_ ? "%llx" : "%lld", x);
+}
+
+
+OStream& OStream::operator<<(unsigned long long x) { // NOLINT(runtime/int)
+ return print(hex_ ? "%llx" : "%llu", x);
+}
+
+
+OStream& OStream::operator<<(double x) {
+ if (std::isinf(x)) return *this << (x < 0 ? "-inf" : "inf");
+ if (std::isnan(x)) return *this << "nan";
+ return print("%g", x);
+}
+
+
+OStream& OStream::operator<<(void* x) {
+ return print("%p", x);
+}
+
+
+OStream& OStream::operator<<(char x) {
+ return put(x);
+}
+
+
+OStream& OStream::operator<<(signed char x) {
+ return put(x);
+}
+
+
+OStream& OStream::operator<<(unsigned char x) {
+ return put(x);
+}
+
+
+OStream& OStream::dec() {
+ hex_ = false;
+ return *this;
+}
+
+
+OStream& OStream::hex() {
+ hex_ = true;
+ return *this;
+}
+
+
+OStream& flush(OStream& os) { // NOLINT(runtime/references)
+ return os.flush();
+}
+
+
+OStream& endl(OStream& os) { // NOLINT(runtime/references)
+ return flush(os.put('\n'));
+}
+
+
+OStream& hex(OStream& os) { // NOLINT(runtime/references)
+ return os.hex();
+}
+
+
+OStream& dec(OStream& os) { // NOLINT(runtime/references)
+ return os.dec();
+}
+
+
+OStringStream& OStringStream::write(const char* s, size_t n) {
+ size_t new_size = size_ + n;
+ if (new_size < size_) return *this; // Overflow => no-op.
+ reserve(new_size + 1);
+ memcpy(data_ + size_, s, n);
+ size_ = new_size;
+ data_[size_] = '\0';
+ return *this;
+}
+
+
+OStringStream& OStringStream::flush() {
+ return *this;
+}
+
+
+void OStringStream::reserve(size_t requested_capacity) {
+ if (requested_capacity <= capacity_) return;
+ size_t new_capacity = // Handle possible overflow by not doubling.
+ std::max(std::max(capacity_ * 2, capacity_), requested_capacity);
+ char * new_data = allocate(new_capacity);
+ memcpy(new_data, data_, size_);
+ deallocate(data_, capacity_);
+ capacity_ = new_capacity;
+ data_ = new_data;
+}
+
+
+OFStream& OFStream::write(const char* s, size_t n) {
+ if (f_) fwrite(s, n, 1, f_);
+ return *this;
+}
+
+
+OFStream& OFStream::flush() {
+ if (f_) fflush(f_);
+ return *this;
+}
+
+
+// Locale-independent predicates.
+static bool IsPrint(uint16_t c) { return 0x20 <= c && c <= 0x7e; }
+static bool IsSpace(uint16_t c) { return (0x9 <= c && c <= 0xd) || c == 0x20; }
+static bool IsOK(uint16_t c) { return (IsPrint(c) || IsSpace(c)) && c != '\\'; }
+
+
+static OStream& PrintUC16(OStream& os, uint16_t c, bool (*pred)(uint16_t)) {
+ char buf[10];
+ const char* format = pred(c) ? "%c" : (c <= 0xff) ? "\\x%02x" : "\\u%04x";
+ snprintf(buf, sizeof(buf), format, c);
+ return os << buf;
+}
+
+
+OStream& operator<<(OStream& os, const AsReversiblyEscapedUC16& c) {
+ return PrintUC16(os, c.value, IsOK);
+}
+
+
+OStream& operator<<(OStream& os, const AsUC16& c) {
+ return PrintUC16(os, c.value, IsPrint);
+}
+} } // namespace v8::internal