Merge in changes from readability review.

src/log.cc

 // Copyright 2009 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 283 matching lines @@
 
   // Opens file for logging.
   static void OpenFile(const char* name);
 
   // Opens memory buffer for logging.
   static void OpenMemoryBuffer();
 
   // Frees all resources acquired in Open... functions.
   static void Close();
 
-  // See description in v8.h.
+  // See description in include/v8.h.
   static int GetLogLines(int from_pos, char* dest_buf, int max_size);
 
-  static bool is_enabled() { return output_.handle != NULL; }
+  // Returns whether logging is enabled.
+  static bool is_enabled() {

[Søren Thygesen Gjesse, 2009/05/25 06:38:31]

How about changing this to IsEnabled() as well? This is no really an accessor.

[Mikhail Naganov, 2009/05/25 08:38:51]

Good idea. Done.

+    return output_handle_ != NULL || output_buffer_ != NULL;
+  }
 
+ private:
   typedef int (*WritePtr)(const char* msg, int length);
- private:
+
+  // Initialization function called from Open... functions.
   static void Init();
 
   // Write functions assume that mutex_ is acquired by the caller.
   static WritePtr Write;
 
+  // Implementation of writing to a log file.
   static int WriteToFile(const char* msg, int length) {
-    ASSERT(output_.handle != NULL);
-    int rv = fwrite(msg, 1, length, output_.handle);
+    ASSERT(output_handle_ != NULL);
+    int rv = fwrite(msg, 1, length, output_handle_);
     ASSERT(length == rv);
     return rv;
   }
 
+  // Implementation of writing to a memory buffer.
   static int WriteToMemory(const char* msg, int length) {
-    ASSERT(output_.buffer != NULL);
-    ASSERT(output_buffer_write_pos_ >= output_.buffer);
+    ASSERT(output_buffer_ != NULL);
+    ASSERT(output_buffer_write_pos_ >= output_buffer_);
     if (output_buffer_write_pos_ + length
-        <= output_.buffer + kOutputBufferSize) {
+        <= output_buffer_ + kOutputBufferSize) {
       memcpy(output_buffer_write_pos_, msg, length);
       output_buffer_write_pos_ += length;
       return length;
     } else {
       // Memory buffer is full, ignore write.
       return 0;
     }
   }
 
-  // When logging is active, output_ refers the file or memory buffer
-  // events are written to.
-  // mutex_ should be acquired before using output_.
-  union Output {
-    FILE* handle;
-    char* buffer;
-  };
-  static Output output_;
+  // When logging is active, either output_handle_ or output_buffer_ is used
+  // to store a pointer to log destination. If logging was opened via OpenStdout
+  // or OpenFile, then output_handle_ is used. If logging was opened
+  // via OpenMemoryBuffer, then output_buffer_ is used.
+  // mutex_ should be acquired before using output_handle_ or output_buffer_.
+  static FILE* output_handle_;
+
+  static char* output_buffer_;
 
   // mutex_ is a Mutex used for enforcing exclusive
   // access to the formatting buffer and the log file or log memory buffer.
   static Mutex* mutex_;
 
   // Size of buffer used for memory logging.
   static const int kOutputBufferSize = 2 * 1024 * 1024;
 
   // Writing position in a memory buffer.
   static char* output_buffer_write_pos_;
 
   // Size of buffer used for formatting log messages.
   static const int kMessageBufferSize = 2048;
 
   // Buffer used for formatting log messages. This is a singleton buffer and
   // mutex_ should be acquired before using it.
   static char* message_buffer_;
 
   friend class LogMessageBuilder;
 };
 
 
 Log::WritePtr Log::Write = NULL;
-Log::Output Log::output_ = {NULL};
+FILE* Log::output_handle_ = NULL;
+char* Log::output_buffer_ = NULL;
 Mutex* Log::mutex_ = NULL;
 char* Log::output_buffer_write_pos_ = NULL;
 char* Log::message_buffer_ = NULL;
 
 
 void Log::Init() {
   mutex_ = OS::CreateMutex();
   message_buffer_ = NewArray<char>(kMessageBufferSize);
 }
 
 
 void Log::OpenStdout() {
-  ASSERT(output_.handle == NULL);
-  output_.handle = stdout;
+  ASSERT(!is_enabled());
+  output_handle_ = stdout;
   Write = WriteToFile;
   Init();
 }
 
 
 void Log::OpenFile(const char* name) {
-  ASSERT(output_.handle == NULL);
-  output_.handle = OS::FOpen(name, OS::LogFileOpenMode);
+  ASSERT(!is_enabled());
+  output_handle_ = OS::FOpen(name, OS::LogFileOpenMode);
   Write = WriteToFile;
   Init();
 }
 
 
 void Log::OpenMemoryBuffer() {
-  ASSERT(output_.buffer == NULL);
-  output_.buffer = NewArray<char>(kOutputBufferSize);
-  output_buffer_write_pos_ = output_.buffer;
+  ASSERT(!is_enabled());
+  output_buffer_ = NewArray<char>(kOutputBufferSize);
+  output_buffer_write_pos_ = output_buffer_;
   Write = WriteToMemory;
   Init();
 }
 
 
 void Log::Close() {
   if (Write == WriteToFile) {
-    fclose(output_.handle);
-    output_.handle = NULL;
+    fclose(output_handle_);
+    output_handle_ = NULL;
   } else if (Write == WriteToMemory) {
-    DeleteArray(output_.buffer);
-    output_.buffer = NULL;
+    DeleteArray(output_buffer_);
+    output_buffer_ = NULL;
   } else {
     ASSERT(Write == NULL);
   }
   Write = NULL;
 
   delete mutex_;
   mutex_ = NULL;
 
   DeleteArray(message_buffer_);
   message_buffer_ = NULL;
 }
 
 
 int Log::GetLogLines(int from_pos, char* dest_buf, int max_size) {
   if (Write != WriteToMemory) return 0;
-  ASSERT(output_.buffer != NULL);
-  ASSERT(output_buffer_write_pos_ >= output_.buffer);
+  ASSERT(output_buffer_ != NULL);
+  ASSERT(output_buffer_write_pos_ >= output_buffer_);
   ASSERT(from_pos >= 0);
   ASSERT(max_size >= 0);
   int actual_size = max_size;
-  char* buffer_read_pos = output_.buffer + from_pos;
+  char* buffer_read_pos = output_buffer_ + from_pos;
   ScopedLock sl(mutex_);
   if (actual_size == 0
-      || output_buffer_write_pos_ == output_.buffer
+      || output_buffer_write_pos_ == output_buffer_
       || buffer_read_pos >= output_buffer_write_pos_) {
     // No data requested or can be returned.
     return 0;
   }
   if (buffer_read_pos + actual_size > output_buffer_write_pos_) {
     // Requested size overlaps with current writing position and
     // needs to be truncated.
     actual_size = output_buffer_write_pos_ - buffer_read_pos;
     ASSERT(actual_size == 0 || buffer_read_pos[actual_size - 1] == '\n');
   } else {
@@ skipping 131 matching lines @@
 //
 // Logger class implementation.
 //
 Ticker* Logger::ticker_ = NULL;
 Profiler* Logger::profiler_ = NULL;
 VMState* Logger::current_state_ = NULL;
 VMState Logger::bottom_state_(EXTERNAL);
 SlidingStateWindow* Logger::sliding_state_window_ = NULL;
 
 
-bool Logger::is_enabled() {
+bool Logger::IsEnabled() {
   return Log::is_enabled();
 }
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 
 void Logger::Preamble(const char* content) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (!Log::is_enabled() || !FLAG_log_code) return;
   LogMessageBuilder msg;
@@ skipping 781 matching lines @@
     } else if (previous_->state_ == EXTERNAL) {
       // We are leaving V8.
       Heap::Protect();
     }
   }
 #endif
 }
 #endif
 
 } }  // namespace v8::internal