Suppress "Waiting for debugger..." message on cosole

runtime/vm/debugger.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/debugger.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
-static const bool verbose = false;
+DEFINE_FLAG(bool, verbose_debug, false, "Verbose debugger messages");
 
 class RemoteObjectCache : public ZoneAllocated {
  public:
   explicit RemoteObjectCache(intptr_t initial_size);
   intptr_t AddObject(const Object& obj);
   RawObject* GetObj(intptr_t obj_id) const;
   bool IsValidId(intptr_t obj_id) const {
     return obj_id < objs_->Length();
   }
 
@@ skipping 642 matching lines @@
   }
   return function.raw();
 }
 
 
 // Deoptimize function if necessary. Does not patch return addresses on the
 // stack. If there are activation frames of this function on the stack,
 // the optimized code will be executed when the callee returns.
 void Debugger::EnsureFunctionIsDeoptimized(const Function& func) {
   if (func.HasOptimizedCode()) {
-    if (verbose) {
+    if (FLAG_verbose_debug) {
       OS::Print("Deoptimizing function %s\n",
                 String::Handle(func.name()).ToCString());
     }
     func.set_usage_counter(0);
     func.set_deoptimization_counter(func.deoptimization_counter() + 1);
     Compiler::CompileFunction(func);
     ASSERT(!func.HasOptimizedCode());
   }
 }
 
@@ skipping 164 matching lines @@
     best_fit_index = lowest_pc_index;
   }
   if (best_fit_index >= 0) {
     CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(best_fit_index));
     // We should only ever have one code breakpoint at the same address.
     if (bpt != NULL) {
       return bpt;
     }
 
     bpt = new CodeBreakpoint(func, best_fit_index);
-    if (verbose) {
+    if (FLAG_verbose_debug) {
       OS::Print("Setting breakpoint in function '%s' (%s:%d) (PC %p)\n",
                 String::Handle(func.name()).ToCString(),
                 String::Handle(bpt->SourceUrl()).ToCString(),
                 bpt->LineNumber(),
                 bpt->pc());
     }
     RegisterCodeBreakpoint(bpt);
     return bpt;
   }
   return NULL;
@@ skipping 30 matching lines @@
   } else {
     bpt = GetSourceBreakpoint(target_function, first_token_pos);
     if (bpt != NULL) {
       // A source breakpoint for this uncompiled location already
       // exists.
       return bpt;
     }
   }
   bpt = new SourceBreakpoint(nextId(), target_function, first_token_pos);
   RegisterSourceBreakpoint(bpt);
-  if (verbose && !target_function.HasCode()) {
+  if (FLAG_verbose_debug && !target_function.HasCode()) {
     OS::Print("Registering breakpoint for "
               "uncompiled function '%s' at line %d\n",
               target_function.ToFullyQualifiedCString(),
               bpt->LineNumber());
   }
 
   if (cbpt != NULL) {
     ASSERT(cbpt->src_bpt() == NULL);
     cbpt->set_src_bpt(bpt);
     SignalBpResolved(bpt);
   } else {
-    if (verbose) {
+    if (FLAG_verbose_debug) {
       OS::Print("Failed to set breakpoint at '%s' line %d\n",
                 String::Handle(bpt->SourceUrl()).ToCString(),
                 bpt->LineNumber());
     }
   }
   bpt->Enable();
   return bpt;
 }
 
 
@@ skipping 30 matching lines @@
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate_->object_store()->libraries());
   for (int i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     script = lib.LookupScript(script_url);
     if (!script.IsNull()) {
       break;
     }
   }
   if (script.IsNull()) {
-    if (verbose) {
+    if (FLAG_verbose_debug) {
       OS::Print("Failed to find script with url '%s'\n",
                 script_url.ToCString());
     }
     return NULL;
   }
   intptr_t first_token_idx, last_token_idx;
   script.TokenRangeAtLine(line_number, &first_token_idx, &last_token_idx);
   if (first_token_idx < 0) {
     // Script does not contain the given line number.
-    if (verbose) {
+    if (FLAG_verbose_debug) {
       OS::Print("Script '%s' does not contain line number %d\n",
                 script_url.ToCString(), line_number);
     }
     return NULL;
   }
   const Function& func =
       Function::Handle(lib.LookupFunctionInScript(script, first_token_idx));
   if (func.IsNull()) {
-    if (verbose) {
+    if (FLAG_verbose_debug) {
       OS::Print("No executable code at line %d in '%s'\n",
                 line_number, script_url.ToCString());
     }
     return NULL;
   }
   if (last_token_idx < 0) {
     // The token at first_token_index is past the requested source line.
     // Set the breakpoint at the closest position after that line.
     last_token_idx = func.end_token_pos();
   }
@@ skipping 264 matching lines @@
 void Debugger::SignalBpReached() {
   if (ignore_breakpoints_) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   ASSERT(stack_trace->Length() > 0);
   ActivationFrame* top_frame = stack_trace->ActivationFrameAt(0);
   ASSERT(top_frame != NULL);
   CodeBreakpoint* bpt = GetCodeBreakpoint(top_frame->pc());
   ASSERT(bpt != NULL);
-  if (verbose) {
+  if (FLAG_verbose_debug) {
     OS::Print(">>> hit %s breakpoint at %s:%d (Address %p)\n",
               bpt->IsInternal() ? "internal" : "user",
               String::Handle(bpt->SourceUrl()).ToCString(),
               bpt->LineNumber(),
               top_frame->pc());
   }
 
   if (!bpt->IsInternal()) {
     // This is a user-defined breakpoint so we call the breakpoint
     // callback even if it is on the same line as the previous breakpoint.
@@ skipping 118 matching lines @@
   }
   SourceBreakpoint* bpt = src_breakpoints_;
   while (bpt != NULL) {
     if (lookup_function.raw() == bpt->function()) {
       // Check if the breakpoint is inside a closure or local function
       // within the newly compiled function.
       Class& owner = Class::Handle(lookup_function.Owner());
       Function& closure =
           Function::Handle(owner.LookupClosureFunction(bpt->token_pos()));
       if (!closure.IsNull() && (closure.raw() != lookup_function.raw())) {
-        if (verbose) {
+        if (FLAG_verbose_debug) {
           OS::Print("Resetting pending breakpoint to function %s\n",
                     closure.ToFullyQualifiedCString());
         }
         bpt->set_function(closure);
       } else {
-        if (verbose) {
+        if (FLAG_verbose_debug) {
           OS::Print("Enable pending breakpoint for function '%s'\n",
                     String::Handle(lookup_function.name()).ToCString());
         }
         // Set breakpoint in newly compiled code of function func.
         CodeBreakpoint* cbpt =
             MakeCodeBreakpoint(func, bpt->token_pos(), func.end_token_pos());
         if (cbpt != NULL) {
           cbpt->set_src_bpt(bpt);
           SignalBpResolved(bpt);
         }
@@ skipping 118 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart