- Account for hidden frames when concatenating throw and

runtime/vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 15227 matching lines @@
 
 void Stacktrace::SetCatchStacktrace(const Array& code_array,
                                     const Array& pc_offset_array) const {
   StorePointer(&raw_ptr()->catch_code_array_, code_array.raw());
   StorePointer(&raw_ptr()->catch_pc_offset_array_, pc_offset_array.raw());
 }
 
 
 RawString* Stacktrace::FullStacktrace() const {
   const Array& code_array = Array::Handle(raw_ptr()->catch_code_array_);
+  intptr_t idx = 0;
   if (!code_array.IsNull() && (code_array.Length() > 0)) {
     const Array& pc_offset_array =
         Array::Handle(raw_ptr()->catch_pc_offset_array_);
     const Stacktrace& catch_trace = Stacktrace::Handle(
         Stacktrace::New(code_array, pc_offset_array));
-    intptr_t idx = Length();
-    const String& trace =
-        String::Handle(String::New(catch_trace.ToCStringInternal(idx)));
-    const String& throw_trace =
-        String::Handle(String::New(ToCStringInternal(0)));
-    return String::Concat(throw_trace, trace);
+    const String& throw_string =
+        String::Handle(String::New(ToCStringInternal(&idx)));
+    const String& catch_string =
+        String::Handle(String::New(catch_trace.ToCStringInternal(&idx)));
+    return String::Concat(throw_string, catch_string);
   }
-  return String::New(ToCStringInternal(0));
+  return String::New(ToCStringInternal(&idx));
 }
 
 
 const char* Stacktrace::ToCString() const {
   const String& trace = String::Handle(FullStacktrace());
   return trace.ToCString();
 }
 
 
 void Stacktrace::PrintToJSONStream(JSONStream* stream, bool ref) const {
@@ skipping 41 matching lines @@
     chars = isolate->current_zone()->Alloc<char>(len + 1);
     OS::SNPrint(chars, (len + 1), kFormatNoCol,
                 frame_index, function_name.ToCString(),
                 url.ToCString(), line);
   }
   frame_strings->Add(chars);
   return len;
 }
 
 
-const char* Stacktrace::ToCStringInternal(intptr_t frame_index) const {
+const char* Stacktrace::ToCStringInternal(intptr_t* frame_index) const {
   Isolate* isolate = Isolate::Current();
   Function& function = Function::Handle();
   Code& code = Code::Handle();
   // Iterate through the stack frames and create C string description
   // for each frame.
   intptr_t total_len = 0;
   GrowableArray<char*> frame_strings;
-  intptr_t current_frame_index = frame_index;
   for (intptr_t i = 0; i < Length(); i++) {
     function = FunctionAtFrame(i);
     if (function.IsNull()) {
       // Check if null function object indicates a stack trace overflow.
       if ((i < (Length() - 1)) &&
           (FunctionAtFrame(i + 1) != Function::null())) {
         const char* kTruncated = "...\n...\n";
         intptr_t truncated_len = strlen(kTruncated) + 1;
         char* chars = isolate->current_zone()->Alloc<char>(truncated_len);
         OS::SNPrint(chars, truncated_len, "%s", kTruncated);
         frame_strings.Add(chars);
       }
     } else if (function.is_visible() || FLAG_verbose_stacktrace) {
       code = CodeAtFrame(i);
       ASSERT(function.raw() == code.function());
       uword pc = code.EntryPoint() + Smi::Value(PcOffsetAtFrame(i));
       if (code.is_optimized() && expand_inlined()) {
         // Traverse inlined frames.
         for (InlinedFunctionsIterator it(code, pc); !it.Done(); it.Advance()) {
           function = it.function();
           code = it.code();
           ASSERT(function.raw() == code.function());
           uword pc = it.pc();
           ASSERT(pc != 0);
           ASSERT(code.EntryPoint() <= pc);
           ASSERT(pc < (code.EntryPoint() + code.Size()));
           total_len += PrintOneStacktrace(
-              isolate, &frame_strings, pc, function, code, current_frame_index);
-          current_frame_index++;  // To account for inlined frames.
+              isolate, &frame_strings, pc, function, code, *frame_index);
+          (*frame_index)++;  // To account for inlined frames.
         }
       } else {
         total_len += PrintOneStacktrace(
-            isolate, &frame_strings, pc, function, code, current_frame_index);
-        current_frame_index++;
+            isolate, &frame_strings, pc, function, code, *frame_index);
+        (*frame_index)++;
       }
     }
   }
 
   // Now concatenate the frame descriptions into a single C string.
   char* chars = isolate->current_zone()->Alloc<char>(total_len + 1);
   intptr_t index = 0;
   for (intptr_t i = 0; i < frame_strings.length(); i++) {
     index += OS::SNPrint((chars + index),
                          (total_len + 1 - index),
@@ skipping 184 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart