/*

 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "compiler/compileLog.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/arguments.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/ostream.hpp"

#include "utilities/top.hpp"

#include "utilities/xmlstream.hpp"

#ifdef TARGET_OS_FAMILY_linux

# include "os_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "os_solaris.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "os_windows.inline.hpp"

#endif

extern "C" void jio_print(const char* s); // Declarationtion of jvm method

outputStream::outputStream(int width) {

  _width       = width;

  _position    = 0;

  _newlines    = 0;

  _precount    = 0;

  _indentation = 0;

}

outputStream::outputStream(int width, bool has_time_stamps) {

  _width       = width;

  _position    = 0;

  _newlines    = 0;

  _precount    = 0;

  _indentation = 0;

  if (has_time_stamps)  _stamp.update();

}

void outputStream::update_position(const char* s, size_t len) {

  for (size_t i = 0; i < len; i++) {

    char ch = s[i];

    if (ch == '\n') {

      _newlines += 1;

      _precount += _position + 1;

      _position = 0;

    } else if (ch == '\t') {

      int tw = 8 - (_position & 7);

      _position += tw;

      _precount -= tw-1;  // invariant:  _precount + _position == total count

    } else {

      _position += 1;

    }

  }

}

// Execute a vsprintf, using the given buffer if necessary.

// Return a pointer to the formatted string.

const char* outputStream::do_vsnprintf(char* buffer, size_t buflen,

                                       const char* format, va_list ap,

                                       bool add_cr,

                                       size_t& result_len) {

  const char* result;

  if (add_cr)  buflen--;

  if (!strchr(format, '%')) {

    // constant format string

    result = format;

    result_len = strlen(result);

    if (add_cr && result_len >= buflen)  result_len = buflen-1;  // truncate

  } else if (format[0] == '%' && format[1] == 's' && format[2] == '\0') {

    // trivial copy-through format string

    result = va_arg(ap, const char*);

    result_len = strlen(result);

    if (add_cr && result_len >= buflen)  result_len = buflen-1;  // truncate

  } else if (vsnprintf(buffer, buflen, format, ap) >= 0) {

    result = buffer;

    result_len = strlen(result);

  } else {

    DEBUG_ONLY(warning("increase O_BUFLEN in ostream.hpp -- output truncated");)

    result = buffer;

    result_len = buflen - 1;

    buffer[result_len] = 0;

  }

  if (add_cr) {

    if (result != buffer) {

      strncpy(buffer, result, buflen);

      result = buffer;

    }

    buffer[result_len++] = '\n';

    buffer[result_len] = 0;

  }

  return result;

}

void outputStream::print(const char* format, ...) {

  char buffer[O_BUFLEN];

  va_list ap;

  va_start(ap, format);

  size_t len;

  const char* str = do_vsnprintf(buffer, O_BUFLEN, format, ap, false, len);

  write(str, len);

  va_end(ap);

}

void outputStream::print_cr(const char* format, ...) {

  char buffer[O_BUFLEN];

  va_list ap;

  va_start(ap, format);

  size_t len;

  const char* str = do_vsnprintf(buffer, O_BUFLEN, format, ap, true, len);

  write(str, len);

  va_end(ap);

}

void outputStream::vprint(const char *format, va_list argptr) {

  char buffer[O_BUFLEN];

  size_t len;

  const char* str = do_vsnprintf(buffer, O_BUFLEN, format, argptr, false, len);

  write(str, len);

}

void outputStream::vprint_cr(const char* format, va_list argptr) {

  char buffer[O_BUFLEN];

  size_t len;

  const char* str = do_vsnprintf(buffer, O_BUFLEN, format, argptr, true, len);

  write(str, len);

}

void outputStream::fill_to(int col) {

  int need_fill = col - position();

  sp(need_fill);

}

void outputStream::move_to(int col, int slop, int min_space) {

  if (position() >= col + slop)

    cr();

  int need_fill = col - position();

  if (need_fill < min_space)

    need_fill = min_space;

  sp(need_fill);

}

void outputStream::put(char ch) {

  assert(ch != 0, "please fix call site");

  char buf[] = { ch, '\0' };

  write(buf, 1);

}

#define SP_USE_TABS false

void outputStream::sp(int count) {

  if (count < 0)  return;

  if (SP_USE_TABS && count >= 8) {

    int target = position() + count;

    while (count >= 8) {

      this->write("\t", 1);

      count -= 8;

    }

    count = target - position();

  }

  while (count > 0) {

    int nw = (count > 8) ? 8 : count;

    this->write("        ", nw);

    count -= nw;

  }

}

void outputStream::cr() {

  this->write("\n", 1);

}

void outputStream::stamp() {

  if (! _stamp.is_updated()) {

    _stamp.update(); // start at 0 on first call to stamp()

  }

  // outputStream::stamp() may get called by ostream_abort(), use snprintf

  // to avoid allocating large stack buffer in print().

  char buf[40];

  jio_snprintf(buf, sizeof(buf), "%.3f", _stamp.seconds());

  print_raw(buf);

}

void outputStream::stamp(bool guard,

                         const char* prefix,

                         const char* suffix) {

  if (!guard) {

    return;

  }

  print_raw(prefix);

  stamp();

  print_raw(suffix);

}

void outputStream::date_stamp(bool guard,

                              const char* prefix,

                              const char* suffix) {

  if (!guard) {

    return;

  }

  print_raw(prefix);

  static const char error_time[] = "yyyy-mm-ddThh:mm:ss.mmm+zzzz";

  static const int buffer_length = 32;

  char buffer[buffer_length];

  const char* iso8601_result = os::iso8601_time(buffer, buffer_length);

  if (iso8601_result != NULL) {

    print_raw(buffer);

  } else {

    print_raw(error_time);

  }

  print_raw(suffix);

  return;

}

void outputStream::indent() {

  while (_position < _indentation) sp();

}

void outputStream::print_jlong(jlong value) {

  // N.B. Same as INT64_FORMAT

  print(os::jlong_format_specifier(), value);

}

void outputStream::print_julong(julong value) {

  // N.B. Same as UINT64_FORMAT

  print(os::julong_format_specifier(), value);

}

stringStream::stringStream(size_t initial_size) : outputStream() {

  buffer_length = initial_size;

  buffer        = NEW_RESOURCE_ARRAY(char, buffer_length);

  buffer_pos    = 0;

  buffer_fixed  = false;

}

// useful for output to fixed chunks of memory, such as performance counters

stringStream::stringStream(char* fixed_buffer, size_t fixed_buffer_size) : outputStream() {

  buffer_length = fixed_buffer_size;

  buffer        = fixed_buffer;

  buffer_pos    = 0;

  buffer_fixed  = true;

}

void stringStream::write(const char* s, size_t len) {

  size_t write_len = len;               // number of non-null bytes to write

  size_t end = buffer_pos + len + 1;    // position after write and final '\0'

  if (end > buffer_length) {

    if (buffer_fixed) {

      // if buffer cannot resize, silently truncate

      end = buffer_length;

      write_len = end - buffer_pos - 1; // leave room for the final '\0'

    } else {

      // For small overruns, double the buffer.  For larger ones,

      // increase to the requested size.

      if (end < buffer_length * 2) {

        end = buffer_length * 2;

      }

      char* oldbuf = buffer;

      buffer = NEW_RESOURCE_ARRAY(char, end);

      strncpy(buffer, oldbuf, buffer_pos);

      buffer_length = end;

    }

  }

  // invariant: buffer is always null-terminated

  guarantee(buffer_pos + write_len + 1 <= buffer_length, "stringStream oob");

  buffer[buffer_pos + write_len] = 0;

  strncpy(buffer + buffer_pos, s, write_len);

  buffer_pos += write_len;

  // Note that the following does not depend on write_len.

  // This means that position and count get updated

  // even when overflow occurs.

  update_position(s, len);

}

char* stringStream::as_string() {

  char* copy = NEW_RESOURCE_ARRAY(char, buffer_pos+1);

  strncpy(copy, buffer, buffer_pos);

  copy[buffer_pos] = 0;  // terminating null

  return copy;

}

stringStream::~stringStream() {}

xmlStream*   xtty;

outputStream* tty;

outputStream* gclog_or_tty;

extern Mutex* tty_lock;

fileStream::fileStream(const char* file_name) {

  _file = fopen(file_name, "w");

  _need_close = true;

}

fileStream::fileStream(const char* file_name, const char* opentype) {

  _file = fopen(file_name, opentype);

  _need_close = true;

}

void fileStream::write(const char* s, size_t len) {

  if (_file != NULL)  {

    // Make an unused local variable to avoid warning from gcc 4.x compiler.

    size_t count = fwrite(s, 1, len, _file);

  }

  update_position(s, len);

}

long fileStream::fileSize() {

  long size = -1;

  if (_file != NULL) {

    long pos  = ::ftell(_file);

    if (::fseek(_file, 0, SEEK_END) == 0) {

      size = ::ftell(_file);

    }

    ::fseek(_file, pos, SEEK_SET);

  }

  return size;

}

char* fileStream::readln(char *data, int count ) {

  char * ret = ::fgets(data, count, _file);

  //Get rid of annoying \n char

  data[::strlen(data)-1] = '\0';

  return ret;

}

fileStream::~fileStream() {

  if (_file != NULL) {

    if (_need_close) fclose(_file);

    _file = NULL;

  }

}

void fileStream::flush() {

  fflush(_file);

}

fdStream::fdStream(const char* file_name) {

  _fd = open(file_name, O_WRONLY | O_CREAT | O_TRUNC, 0666);

  _need_close = true;

}

fdStream::~fdStream() {

  if (_fd != -1) {

    if (_need_close) close(_fd);

    _fd = -1;

  }

}

void fdStream::write(const char* s, size_t len) {

  if (_fd != -1) {

    // Make an unused local variable to avoid warning from gcc 4.x compiler.

    size_t count = ::write(_fd, s, (int)len);

  }

  update_position(s, len);

}

defaultStream* defaultStream::instance = NULL;

int defaultStream::_output_fd = 1;

int defaultStream::_error_fd  = 2;

FILE* defaultStream::_output_stream = stdout;

FILE* defaultStream::_error_stream  = stderr;

#define LOG_MAJOR_VERSION 160

#define LOG_MINOR_VERSION 1

void defaultStream::init() {

  _inited = true;

  if (LogVMOutput || LogCompilation) {

    init_log();

  }

}

bool defaultStream::has_log_file() {

  // lazily create log file (at startup, LogVMOutput is false even

  // if +LogVMOutput is used, because the flags haven't been parsed yet)

  // For safer printing during fatal error handling, do not init logfile

  // if a VM error has been reported.

  if (!_inited && !is_error_reported())  init();

  return _log_file != NULL;

}

static const char* make_log_name(const char* log_name, const char* force_directory) {

  const char* basename = log_name;

  char file_sep = os::file_separator()[0];

  const char* cp;

  for (cp = log_name; *cp != '\0'; cp++) {

    if (*cp == '/' || *cp == file_sep) {

      basename = cp+1;

    }

  }

  const char* nametail = log_name;

  // Compute buffer length

  size_t buffer_length;

  if (force_directory != NULL) {

    buffer_length = strlen(force_directory) + strlen(os::file_separator()) +

                    strlen(basename) + 1;

  } else {

    buffer_length = strlen(log_name) + 1;

  }

  const char* star = strchr(basename, '*');

  int star_pos = (star == NULL) ? -1 : (star - nametail);

  int skip = 1;

  if (star == NULL) {

    // Try %p

    star = strstr(basename, "%p");

    if (star != NULL) {

      skip = 2;

    }

  }

  star_pos = (star == NULL) ? -1 : (star - nametail);

  char pid[32];

  if (star_pos >= 0) {

    jio_snprintf(pid, sizeof(pid), "%u", os::current_process_id());

    buffer_length += strlen(pid);

  }

  // Create big enough buffer.

  char *buf = NEW_C_HEAP_ARRAY(char, buffer_length);

  strcpy(buf, "");

  if (force_directory != NULL) {

    strcat(buf, force_directory);

    strcat(buf, os::file_separator());

    nametail = basename;       // completely skip directory prefix

  }

  if (star_pos >= 0) {

    // convert foo*bar.log or foo%pbar.log to foo123bar.log

    int buf_pos = (int) strlen(buf);

    strncpy(&buf[buf_pos], nametail, star_pos);

    strcpy(&buf[buf_pos + star_pos], pid);

    nametail += star_pos + skip;  // skip prefix and pid format

  }

  strcat(buf, nametail);      // append rest of name, or all of name

  return buf;

}

void defaultStream::init_log() {

  // %%% Need a MutexLocker?

  const char* log_name = LogFile != NULL ? LogFile : "hotspot.log";

  const char* try_name = make_log_name(log_name, NULL);

  fileStream* file = new(ResourceObj::C_HEAP) fileStream(try_name);

  if (!file->is_open()) {

    // Try again to open the file.

    char warnbuf[O_BUFLEN*2];

    jio_snprintf(warnbuf, sizeof(warnbuf),

                 "Warning:  Cannot open log file: %s\n", try_name);

    // Note:  This feature is for maintainer use only.  No need for L10N.

    jio_print(warnbuf);

    FREE_C_HEAP_ARRAY(char, try_name);

    try_name = make_log_name("hs_pid%p.log", os::get_temp_directory());

    jio_snprintf(warnbuf, sizeof(warnbuf),

                 "Warning:  Forcing option -XX:LogFile=%s\n", try_name);

    jio_print(warnbuf);

    delete file;

    file = new(ResourceObj::C_HEAP) fileStream(try_name);

    FREE_C_HEAP_ARRAY(char, try_name);

  }

  if (file->is_open()) {

    _log_file = file;

    xmlStream* xs = new(ResourceObj::C_HEAP) xmlStream(file);

    _outer_xmlStream = xs;

    if (this == tty)  xtty = xs;

    // Write XML header.

    xs->print_cr("<?xml version='1.0' encoding='UTF-8'?>");

    // (For now, don't bother to issue a DTD for this private format.)

    jlong time_ms = os::javaTimeMillis() - tty->time_stamp().milliseconds();

    // %%% Should be: jlong time_ms = os::start_time_milliseconds(), if

    // we ever get round to introduce that method on the os class

    xs->head("hotspot_log version='%d %d'"

             " process='%d' time_ms='"INT64_FORMAT"'",

             LOG_MAJOR_VERSION, LOG_MINOR_VERSION,

             os::current_process_id(), time_ms);

    // Write VM version header immediately.

    xs->head("vm_version");

    xs->head("name"); xs->text("%s", VM_Version::vm_name()); xs->cr();

    xs->tail("name");

    xs->head("release"); xs->text("%s", VM_Version::vm_release()); xs->cr();

    xs->tail("release");

    xs->head("info"); xs->text("%s", VM_Version::internal_vm_info_string()); xs->cr();

    xs->tail("info");

    xs->tail("vm_version");

    // Record information about the command-line invocation.

    xs->head("vm_arguments");  // Cf. Arguments::print_on()

    if (Arguments::num_jvm_flags() > 0) {

      xs->head("flags");

      Arguments::print_jvm_flags_on(xs->text());

      xs->tail("flags");

    }