Untank compilation and fix JSON parse bug introduced in r8147.

src/json-parser.cc

 // Copyright 2011 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 149 matching lines @@
 Handle<Object> JsonParser::ParseJsonObject() {
   Handle<JSFunction> object_constructor(
       isolate()->global_context()->object_function());
   Handle<JSObject> json_object =
       isolate()->factory()->NewJSObject(object_constructor);
   ASSERT_EQ(c0_, '{');
 
   AdvanceSkipWhitespace();
   if (c0_ != '}') {
     do {
+      if (c0_ != '"') return ReportUnexpectedCharacter();
       Handle<String> key = ParseJsonSymbol();
       if (key.is_null() || c0_ != ':') return ReportUnexpectedCharacter();
       AdvanceSkipWhitespace();
       Handle<Object> value = ParseJsonValue();
       if (value.is_null()) return ReportUnexpectedCharacter();
 
       uint32_t index;
       if (key->AsArrayIndex(&index)) {
         SetOwnElement(json_object, index, value, kNonStrictMode);
       } else if (key->Equals(isolate()->heap()->Proto_symbol())) {
@@ skipping 96 matching lines @@
     number_ = StringToDouble(isolate()->unicode_cache(),
                              result,
                              NO_FLAGS,  // Hex, octal or trailing junk.
                              0.0);
     buffer.Dispose();
   }
   SkipWhitespace();
   return isolate()->factory()->NewNumber(number_);
 }
 
-Handle<Object> JsonParser::SlowScanJsonString() {
+Handle<String> JsonParser::SlowScanJsonString() {
   // The currently scanned ascii characters.
   Handle<String> ascii(isolate()->factory()->NewSubString(source_,
                                                           beg_pos_,
                                                           position_));
   Handle<String> two_byte =
       isolate()->factory()->NewRawTwoByteString(kInitialSpecialStringSize,
                                                 NOT_TENURED);
   Handle<SeqTwoByteString> seq_two_byte =
       Handle<SeqTwoByteString>::cast(two_byte);
 
   int allocation_count = 1;
   int count = 0;
 
   while (c0_ != '"') {
     // Create new seq string
     if (count >= kInitialSpecialStringSize * allocation_count) {
       allocation_count = allocation_count * 2;
       int new_size = allocation_count * kInitialSpecialStringSize;
       Handle<String> new_two_byte =
           isolate()->factory()->NewRawTwoByteString(new_size,
                                                     NOT_TENURED);
       uc16* char_start =
           Handle<SeqTwoByteString>::cast(new_two_byte)->GetChars();
       String::WriteToFlat(*seq_two_byte, char_start, 0, count);
       seq_two_byte = Handle<SeqTwoByteString>::cast(new_two_byte);
     }
 
     // Check for control character (0x00-0x1f) or unterminated string (<0).
-    if (c0_ < 0x20) return ReportUnexpectedCharacter();
+    if (c0_ < 0x20) return Handle<String>::null();
     if (c0_ != '\\') {
       seq_two_byte->SeqTwoByteStringSet(count++, c0_);
       Advance();
     } else {
       Advance();
       switch (c0_) {
         case '"':
         case '\\':
         case '/':
           seq_two_byte->SeqTwoByteStringSet(count++, c0_);
@@ skipping 12 matching lines @@
           break;
         case 't':
           seq_two_byte->SeqTwoByteStringSet(count++, '\x09');
           break;
         case 'u': {
           uc32 value = 0;
           for (int i = 0; i < 4; i++) {
             Advance();
             int digit = HexValue(c0_);
             if (digit < 0) {
-              return ReportUnexpectedCharacter();
+              return Handle<String>::null();
             }
             value = value * 16 + digit;
           }
           seq_two_byte->SeqTwoByteStringSet(count++, value);
           break;
         }
         default:
-          return ReportUnexpectedCharacter();
+          return Handle<String>::null();
       }
       Advance();
     }
   }
   // Advance past the last '"'.
   ASSERT_EQ('"', c0_);
   AdvanceSkipWhitespace();
 
   // Shrink the the string to our length.
   if (isolate()->heap()->InNewSpace(*seq_two_byte)) {
     isolate()->heap()->new_space()->
           ShrinkStringAtAllocationBoundary<SeqTwoByteString>(*seq_two_byte,
                                                              count);
   } else {
     int string_size = SeqTwoByteString::SizeFor(count);
     int allocated_string_size =
         SeqTwoByteString::SizeFor(kInitialSpecialStringSize * allocation_count);
     int delta = allocated_string_size - string_size;
     Address start_filler_object = seq_two_byte->address() + string_size;
     seq_two_byte->set_length(count);
     isolate()->heap()->CreateFillerObjectAt(start_filler_object, delta);
   }
   return isolate()->factory()->NewConsString(ascii, seq_two_byte);
 }
 
 
 template <bool is_symbol>
-Handle<Object> JsonParser::ScanJsonString() {
+Handle<String> JsonParser::ScanJsonString() {
   ASSERT_EQ('"', c0_);
   Advance();
   beg_pos_ = position_;
   // Fast case for ascii only without escape characters.
   while (c0_ != '"') {
     // Check for control character (0x00-0x1f) or unterminated string (<0).
-    if (c0_ < 0x20) return ReportUnexpectedCharacter();
+    if (c0_ < 0x20) return Handle<String>::null();
     if (c0_ != '\\' && c0_ < kMaxAsciiCharCode) {
       Advance();
     } else {
       return SlowScanJsonString();
     }
   }
   ASSERT_EQ('"', c0_);
   end_pos_ = position_;
   // Advance past the last '"'.
   AdvanceSkipWhitespace();
   if (is_sequential_ascii_ && is_symbol) {
     return isolate()->factory()->LookupAsciiSymbol(seq_source_,
                                                    beg_pos_,
                                                    end_pos_ - beg_pos_);
   } else {
     return isolate()->factory()->NewSubString(source_, beg_pos_, end_pos_);
   }
 }
 
 } }  // namespace v8::internal