Added special case for atomic regular expressions.

src/log.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 240 matching lines @@
 FILE* Logger::logfile_ = NULL;
 Profiler* Logger::profiler_ = NULL;
 Mutex* Logger::mutex_ = NULL;
 VMState* Logger::current_state_ = NULL;
 SlidingStateWindow* Logger::sliding_state_window_ = NULL;
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 void Logger::Preamble(const char* content) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  if (logfile_ == NULL) return;
+  if (logfile_ == NULL || !FLAG_log) return;
   ScopedLock sl(mutex_);
   fprintf(logfile_, "%s", content);
 #endif
 }
 
 
 void Logger::StringEvent(const char* name, const char* value) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  if (logfile_ == NULL) return;
+  if (logfile_ == NULL || !FLAG_log) return;
   ScopedLock sl(mutex_);
   fprintf(logfile_, "%s,\"%s\"\n", name, value);
 #endif
 }
 
 
 void Logger::IntEvent(const char* name, int value) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  if (logfile_ == NULL) return;
+  if (logfile_ == NULL || !FLAG_log) return;
   ScopedLock sl(mutex_);
   fprintf(logfile_, "%s,%d\n", name, value);
 #endif
 }
 
 
 void Logger::HandleEvent(const char* name, Object** location) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (logfile_ == NULL || !FLAG_log_handles) return;
   ScopedLock sl(mutex_);
@@ skipping 63 matching lines @@
   //      (re.global?"g":"") + (re.ignorecase?"i":"") + (re.multiline?"m":"")
 
   Handle<Object> source = GetProperty(regexp, "source");
   if (!source->IsString()) {
     fprintf(logfile_, "no source");
     return;
   }
   Handle<String> source_string = Handle<String>::cast(source);
 
   SmartPointer<uc16> cstring = source_string->ToWideCString();
+  if (regexp->type()->IsSmi()) {
+    switch (regexp->type_tag()) {
+    case JSRegExp::ATOM:
+      fprintf(logfile_, "a");
+      break;
+    default:
+      break;
+    }
+  }
   fprintf(logfile_, "/");
   for (int i = 0, n = source_string->length(); i < n; i++) {
     uc16 c = cstring[i];
     if (c < 32 || (c > 126 && c <= 255)) {
       fprintf(logfile_, "\\x%02x", c);
     } else if (c > 255) {
       fprintf(logfile_, "\\u%04x", c);
     } else {
       fprintf(logfile_, "%lc", c);
     }
@@ skipping 95 matching lines @@
 void Logger::ApiEntryCall(const char* name) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (logfile_ == NULL || !FLAG_log_api) return;
   Logger::ApiEvent("api,%s\n", name);
 #endif
 }
 
 
 void Logger::NewEvent(const char* name, void* object, size_t size) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  if (logfile_ == NULL) return;
+  if (logfile_ == NULL || !FLAG_log) return;
   ScopedLock sl(mutex_);
   fprintf(logfile_, "new,%s,0x%x,%u\n", name,
           reinterpret_cast<unsigned int>(object),
           static_cast<unsigned int>(size));
 #endif
 }
 
 
 void Logger::DeleteEvent(const char* name, void* object) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  if (logfile_ == NULL) return;
+  if (logfile_ == NULL || !FLAG_log) return;
   ScopedLock sl(mutex_);
   fprintf(logfile_, "delete,%s,0x%x\n", name,
           reinterpret_cast<unsigned int>(object));
 #endif
 }
 
 
 void Logger::CodeCreateEvent(const char* tag, Code* code, const char* comment) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (logfile_ == NULL || !FLAG_log_code) return;
@@ skipping 52 matching lines @@
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (logfile_ == NULL || !FLAG_log_code) return;
   ScopedLock sl(mutex_);
   fprintf(logfile_, "code-delete,0x%x\n", reinterpret_cast<unsigned int>(from));
 #endif
 }
 
 
 void Logger::ResourceEvent(const char* name, const char* tag) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  if (logfile_ == NULL) return;
+  if (logfile_ == NULL || !FLAG_log) return;
   ScopedLock sl(mutex_);
   fprintf(logfile_, "%s,%s,", name, tag);
 
   uint32_t sec, usec;
   if (OS::GetUserTime(&sec, &usec) != -1) {
     fprintf(logfile_, "%d,%d,", sec, usec);
   }
   fprintf(logfile_, "%.0f", OS::TimeCurrentMillis());
 
   fprintf(logfile_, "\n");
@@ skipping 36 matching lines @@
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (logfile_ == NULL || !FLAG_log_gc) return;
   ScopedLock sl(mutex_);
   fprintf(logfile_, "heap-sample-item,%s,%d,%d\n", type, number, bytes);
 #endif
 }
 
 
 void Logger::DebugTag(const char* call_site_tag) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  if (logfile_ == NULL) return;
+  if (logfile_ == NULL || !FLAG_log) return;
   ScopedLock sl(mutex_);
   fprintf(logfile_, "debug-tag,%s\n", call_site_tag);
 #endif
 }
 
 
 void Logger::DebugEvent(const char* event_type, Vector<uint16_t> parameter) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  if (logfile_ == NULL) return;
+  if (logfile_ == NULL || !FLAG_log) return;
   StringBuilder s(parameter.length() + 1);
   for (int i = 0; i < parameter.length(); ++i) {
     s.AddCharacter(static_cast<char>(parameter[i]));
   }
   char* parameter_string = s.Finalize();
   ScopedLock sl(mutex_);
   fprintf(logfile_,
           "debug-queue-event,%s,%15.3f,%s\n",
           event_type,
           OS::TimeCurrentMillis(),
           parameter_string);
   DeleteArray(parameter_string);
 #endif
 }
 
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 void Logger::TickEvent(TickSample* sample, bool overflow) {
-  if (logfile_ == NULL) return;
+  if (logfile_ == NULL || !FLAG_log) return;
   ScopedLock sl(mutex_);
   fprintf(logfile_, "tick,0x%x,0x%x,%d", sample->pc, sample->sp,
           static_cast<int>(sample->state));
   if (overflow) fprintf(logfile_, ",overflow");
   fprintf(logfile_, "\n");
 }
 #endif
 
 
 bool Logger::Setup() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   // --log-all enables all the log flags.
   if (FLAG_log_all) {
     FLAG_log_api = true;
     FLAG_log_code = true;
     FLAG_log_gc = true;
     FLAG_log_suspect = true;
     FLAG_log_handles = true;
     FLAG_log_regexp = true;
   }
 
   // --prof implies --log-code.
   if (FLAG_prof) FLAG_log_code = true;
 
-  // Each of the individual log flags implies --log.  Check after
-  // checking --log-all and --prof in case they set --log-code.
-  if (FLAG_log_api || FLAG_log_code || FLAG_log_gc ||
-      FLAG_log_handles || FLAG_log_suspect || FLAG_log_regexp) {
-    FLAG_log = true;
-  }
+  bool open_log_file = FLAG_log || FLAG_log_api || FLAG_log_code
+      || FLAG_log_gc || FLAG_log_handles || FLAG_log_suspect
+      || FLAG_log_regexp;
 
   // If we're logging anything, we need to open the log file.
-  if (FLAG_log) {
+  if (open_log_file) {
     if (strcmp(FLAG_logfile, "-") == 0) {
       logfile_ = stdout;
     } else {
       logfile_ = OS::FOpen(FLAG_logfile, "w");
     }
     mutex_ = OS::CreateMutex();
   }
 
   current_state_ = new VMState(OTHER);
 
@@ skipping 100 matching lines @@
   if (FLAG_log_state_changes) {
     LOG(StringEvent("Leaving", StateToString(state_)));
     if (previous_) {
       LOG(StringEvent("To", StateToString(previous_->state_)));
     }
   }
 }
 #endif
 
 } }  // namespace v8::internal