Fix build warnings.

src/objects.cc

 // Copyright 2012 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 1050 matching lines @@
     uint16_t c = stream.GetNext();
 
     if (c < 32 || c >= 127) {
       ascii = false;
     }
   }
   stream.Reset(this);
   if (ascii) {
     accumulator->Add("<String[%u]: ", length());
     for (int i = 0; i < len; i++) {
-      accumulator->Put(stream.GetNext());
+      accumulator->Put(static_cast<char>(stream.GetNext()));
     }
     accumulator->Put('>');
   } else {
     // Backslash indicates that the string contains control
     // characters and that backslashes are therefore escaped.
     accumulator->Add("<String[%u]\\: ", length());
     for (int i = 0; i < len; i++) {
       uint16_t c = stream.GetNext();
       if (c == '\n') {
         accumulator->Add("\\n");
       } else if (c == '\r') {
         accumulator->Add("\\r");
       } else if (c == '\\') {
         accumulator->Add("\\\\");
       } else if (c < 32 || c > 126) {
         accumulator->Add("\\x%02x", c);
       } else {
-        accumulator->Put(c);
+        accumulator->Put(static_cast<char>(c));
       }
     }
     if (truncated) {
       accumulator->Put('.');
       accumulator->Put('.');
       accumulator->Put('.');
     }
     accumulator->Put('>');
   }
   return;
@@ skipping 6426 matching lines @@
   static inline bool compare(const uint8_t* a, const uint8_t* b, int len) {
     return CompareRawStringContents(a, b, len);
   }
 };
 
 
 class StringComparator {
   class State {
    public:
     explicit inline State(ConsStringIteratorOp* op)
-      : op_(op) {}
+      : op_(op), is_one_byte_(true), length_(0), buffer8_(NULL) {}
 
     inline void Init(String* string, unsigned len) {
       op_->Reset();
       int32_t type = string->map()->instance_type();
       String::Visit(string, 0, *this, *op_, type, len);
     }
 
     inline void VisitOneByteString(const uint8_t* chars, unsigned length) {
       is_one_byte_ = true;
       buffer8_ = chars;
@@ skipping 13 matching lines @@
         if (is_one_byte_) {
           buffer8_ += consumed;
         } else {
           buffer16_ += consumed;
         }
         length_ -= consumed;
         return;
       }
       // Advance state.
       ASSERT(op_->HasMore());
-      int32_t type;
-      unsigned length;
+      int32_t type = 0;
+      unsigned length = 0;
       String* next = op_->ContinueOperation(&type, &length);
       ASSERT(next != NULL);
       ConsStringNullOp null_op;
       String::Visit(next, 0, *this, null_op, type, length);
     }
 
     ConsStringIteratorOp* const op_;
     bool is_one_byte_;
-    unsigned offset_;
     unsigned length_;
     union {
       const uint8_t* buffer8_;
       const uint16_t* buffer16_;
     };
     DISALLOW_IMPLICIT_CONSTRUCTORS(State);
   };
 
  public:
   inline StringComparator(ConsStringIteratorOp* op_1,
@@ skipping 6552 matching lines @@
   set_year(Smi::FromInt(year), SKIP_WRITE_BARRIER);
   set_month(Smi::FromInt(month), SKIP_WRITE_BARRIER);
   set_day(Smi::FromInt(day), SKIP_WRITE_BARRIER);
   set_weekday(Smi::FromInt(weekday), SKIP_WRITE_BARRIER);
   set_hour(Smi::FromInt(hour), SKIP_WRITE_BARRIER);
   set_min(Smi::FromInt(min), SKIP_WRITE_BARRIER);
   set_sec(Smi::FromInt(sec), SKIP_WRITE_BARRIER);
 }
 
 } }  // namespace v8::internal