[debugging] print ranges for consecutive values with %DebugPrint

src/objects-printer.cc

 // Copyright 2012 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/objects.h"
 
+#include <iomanip>
+
 #include "src/disasm.h"
 #include "src/disassembler.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/objects-inl.h"
 #include "src/ostreams.h"
 #include "src/regexp/jsregexp.h"
 
 namespace v8 {
 namespace internal {
 
@@ skipping 294 matching lines @@
   } else if (IsJSGlobalObject()) {
     global_dictionary()->Print(os);
   } else {
     property_dictionary()->Print(os);
   }
 }
 
 
 template <class T>
 static void DoPrintElements(std::ostream& os, Object* object) {  // NOLINT
-  T* p = T::cast(object);
-  for (int i = 0; i < p->length(); i++) {
-    os << "\n   " << i << ": " << p->get_scalar(i);
+  T* array = T::cast(object);
+  if (array->length() == 0) return;
+  int previous_index = 0;
+  double previous_value = array->get_scalar(0);
+  double value;
+  int i;
+  for (i = 1; i <= array->length(); i++) {
+    if (i < array->length()) value = array->get_scalar(i);
+    bool values_are_nan = previous_value != previous_value && value != value;

[Yang, 2016/07/26 13:33:42]

isnan()?

+    if ((previous_value == value || values_are_nan) && i != array->length()) {
+      continue;
+    }
+    os << "\n";
+    std::stringstream ss;
+    ss << previous_index;
+    if (previous_index != i - 1) {
+      ss << '-' << (i - 1);
+    }
+    os << std::setw(12) << ss.str() << ": ";
+    if (previous_value == previous_value) {
+      os << previous_value;
+    } else {
+      os << "<the_hole>";

[Yang, 2016/07/26 13:36:34]

as discussed, this could also just be a non-hole nan.

+    }
+    previous_index = i;
+    previous_value = value;
   }
 }
 
 
 void JSObject::PrintElements(std::ostream& os) {  // NOLINT
   // Don't call GetElementsKind, its validation code can cause the printer to
   // fail when debugging.
+  if (elements()->length() == 0) return;
   switch (map()->elements_kind()) {
     case FAST_HOLEY_SMI_ELEMENTS:
     case FAST_SMI_ELEMENTS:
     case FAST_HOLEY_ELEMENTS:
     case FAST_ELEMENTS:
     case FAST_STRING_WRAPPER_ELEMENTS: {
       // Print in array notation for non-sparse arrays.
-      FixedArray* p = FixedArray::cast(elements());
-      for (int i = 0; i < p->length(); i++) {
-        os << "\n   " << i << ": " << Brief(p->get(i));
+      FixedArray* array = FixedArray::cast(elements());
+      Object* previous_value = array->get(0);
+      Object* value;
+      int previous_index = 0;
+      int i;
+      for (i = 1; i <= array->length(); i++) {
+        if (i < array->length()) value = array->get(i);
+        if (previous_value == value && i != array->length()) {
+          continue;
+        }
+        os << "\n";
+        std::stringstream ss;
+        ss << previous_index;
+        if (previous_index != i - 1) {
+          ss << '-' << (i - 1);
+        }
+        os << std::setw(12) << ss.str() << ": " << Brief(previous_value);
+        previous_index = i;
+        previous_value = value;
       }
       break;
     }
     case FAST_HOLEY_DOUBLE_ELEMENTS:
     case FAST_DOUBLE_ELEMENTS: {
-      // Print in array notation for non-sparse arrays.
-      if (elements()->length() > 0) {
-        FixedDoubleArray* p = FixedDoubleArray::cast(elements());
-        for (int i = 0; i < p->length(); i++) {
-          os << "\n   " << i << ": ";
-          if (p->is_the_hole(i)) {
-            os << "<the hole>";
-          } else {
-            os << p->get_scalar(i);
-          }
-        }
-      }
+      DoPrintElements<FixedDoubleArray>(os, elements());
       break;
     }
 
 
 #define PRINT_ELEMENTS(Kind, Type)         \
   case Kind: {                             \
     DoPrintElements<Type>(os, elements()); \
     break;                                 \
   }
 
@@ skipping 1052 matching lines @@
 void JSObject::PrintTransitions(std::ostream& os) {  // NOLINT
   Object* transitions = map()->raw_transitions();
   int num_transitions = TransitionArray::NumberOfTransitions(transitions);
   if (num_transitions == 0) return;
   os << "\n - transitions";
   TransitionArray::PrintTransitions(os, transitions, false);
 }
 #endif  // defined(DEBUG) || defined(OBJECT_PRINT)
 }  // namespace internal
 }  // namespace v8