Only enable dot printing in debug mode

src/jsregexp.cc

 // Copyright 2006-2008 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 896 matching lines @@
     visitor->Visit##Type(this);                                      \
   }
 FOR_EACH_NODE_TYPE(DEFINE_ACCEPT)
 #undef DEFINE_ACCEPT
 
 
 // -------------------------------------------------------------------
 // Dot/dotty output
 
 
+#ifdef DEBUG
+
+
 class DotPrinter: public NodeVisitor {
  public:
   DotPrinter() : stream_(&alloc_) { }
   void PrintNode(const char* label, RegExpNode* node);
   void Visit(RegExpNode* node);
   void PrintOnFailure(RegExpNode* from, RegExpNode* on_failure);
   StringStream* stream() { return &stream_; }
 #define DECLARE_VISIT(Type)                                          \
   virtual void Visit##Type(Type##Node* that);
 FOR_EACH_NODE_TYPE(DECLARE_VISIT)
@@ skipping 28 matching lines @@
 
 
 void DotPrinter::Visit(RegExpNode* node) {
   if (seen_.find(node) != seen_.end())
     return;
   seen_.insert(node);
   node->Accept(this);
 }
 
 
-#ifdef DEBUG
-
-
 void DotPrinter::PrintOnFailure(RegExpNode* from, RegExpNode* on_failure) {
   if (on_failure == EndNode::GetBacktrack()) return;
   stream()->Add("  n%p -> n%p [style=dotted];\n", from, on_failure);
   Visit(on_failure);
 }
 
 
 void DotPrinter::VisitChoice(ChoiceNode* that) {
   stream()->Add("  n%p [label=\"? (%p)\"];\n", that, that);
   PrintOnFailure(that, that->on_failure());
@@ skipping 90 matching lines @@
     case ActionNode::END_SUBMATCH:
       stream()->Add("label=\"end\", shape=septagon");
       break;
   }
   stream()->Add("];\n");
   stream()->Add("  n%p -> n%p;\n", that, that->on_success());
   Visit(that->on_success());
 }
 
 
+class DispatchTableDumper {
+ public:
+  DispatchTableDumper(StringStream* stream) : stream_(stream) { }
+  void Call(uc16 key, DispatchTable::Entry entry);
+  StringStream* stream() { return stream_; }
+ private:
+  StringStream* stream_;
+};
+
+
+void DispatchTableDumper::Call(uc16 key, DispatchTable::Entry entry) {
+  stream()->Add("[%k-%k]: {", key, entry.to());
+  OutSet set = entry.out_set();
+  bool first = true;
+  for (unsigned i = 0; i < OutSet::kFirstLimit; i++) {
+    if (set.Get(i)) {
+      if (first) first = false;
+      else stream()->Add(", ");
+      stream()->Add("%i", i);
+    }
+  }
+  stream()->Add("}\n");
+}
+
+
+void DispatchTable::Dump() {
+  HeapStringAllocator alloc;
+  StringStream stream(&alloc);
+  tree()->ForEach(DispatchTableDumper(&stream));
+  OS::PrintError("%s", *stream.ToCString());
+}
+
+
+void RegExpEngine::DotPrint(const char* label, RegExpNode* node) {
+  DotPrinter printer;
+  printer.PrintNode(label, node);
+}
+
+
 #endif // DEBUG
 
 
 // -------------------------------------------------------------------
 // Tree to graph conversion
 
 
 RegExpNode* RegExpAtom::ToNode(RegExpCompiler* compiler,
                                RegExpNode* on_success,
                                RegExpNode* on_failure) {
@@ skipping 356 matching lines @@
       // There is no overlap so we can just add the range
       ZoneSplayTree<Config>::Locator ins;
       ASSERT_RESULT(tree()->Insert(current.from(), &ins));
       ins.set_value(Entry(current.from(), current.to(), value));
       break;
     }
   }
 }
 
 
-#ifdef DEBUG
-
-
-class DispatchTableDumper {
- public:
-  DispatchTableDumper(StringStream* stream) : stream_(stream) { }
-  void Call(uc16 key, DispatchTable::Entry entry);
-  StringStream* stream() { return stream_; }
- private:
-  StringStream* stream_;
-};
-
-
-void DispatchTableDumper::Call(uc16 key, DispatchTable::Entry entry) {
-  stream()->Add("[%k-%k]: {", key, entry.to());
-  OutSet set = entry.out_set();
-  bool first = true;
-  for (unsigned i = 0; i < OutSet::kFirstLimit; i++) {
-    if (set.Get(i)) {
-      if (first) first = false;
-      else stream()->Add(", ");
-      stream()->Add("%i", i);
-    }
-  }
-  stream()->Add("}\n");
-}
-
-
-void DispatchTable::Dump() {
-  HeapStringAllocator alloc;
-  StringStream stream(&alloc);
-  tree()->ForEach(DispatchTableDumper(&stream));
-  OS::PrintError("%s", *stream.ToCString());
-}
-
-
-#endif
-
-
 OutSet DispatchTable::Get(uc16 value) {
   ZoneSplayTree<Config>::Locator loc;
   if (!tree()->FindGreatestLessThan(value, &loc))
     return OutSet::empty();
   Entry* entry = &loc.value();
   if (value <= entry->to())
     return entry->out_set();
   else
     return OutSet::empty();
 }
@@ skipping 95 matching lines @@
 RegExpNode* RegExpCompiler::Compile(RegExpTree* tree,
                                     RegExpNode* on_success,
                                     RegExpNode* on_failure) {
   RegExpNode* node = tree->ToNode(this, on_success, on_failure);
   Analysis analysis(this);
   analysis.Analyze(node);
   return node;
 }
 
 
-void RegExpEngine::DotPrint(const char* label, RegExpNode* node) {
-  DotPrinter printer;
-  printer.PrintNode(label, node);
-}
-
-
 RegExpNode* RegExpEngine::Compile(RegExpParseResult* input) {
   RegExpCompiler compiler(input->capture_count);
   RegExpNode* node = compiler.Compile(input->tree,
                                       EndNode::GetAccept(),
                                       EndNode::GetBacktrack());
   return node;
 }
 
 
 }}  // namespace v8::internal