/*

 * Copyright (c) 1997, 2017, 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 "runtime/os.hpp"

#include "runtime/vm_version.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/macros.hpp"

#include "utilities/ostream.hpp"

#include "utilities/vmError.hpp"

#include "utilities/xmlstream.hpp"

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;

  _scratch     = NULL;

  _scratch_len = 0;

}

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

  _width       = width;

  _position    = 0;

  _newlines    = 0;

  _precount    = 0;

  _indentation = 0;

  _scratch     = NULL;

  _scratch_len = 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) {

  assert(buflen >= 2, "buffer too small");

  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 {

    // Handle truncation:

    // posix: upon truncation, vsnprintf returns number of bytes which

    //   would have been written (excluding terminating zero) had the buffer

    //   been large enough

    // windows: upon truncation, vsnprintf returns -1

    const int written = vsnprintf(buffer, buflen, format, ap);

    result = buffer;

    if (written < (int) buflen && written >= 0) {

      result_len = written;

    } else {

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

      result_len = buflen - 1;

      buffer[result_len] = 0;

    }

  }

  if (add_cr) {

    if (result != buffer) {

      memcpy(buffer, result, result_len);

      result = buffer;

    }

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

    buffer[result_len] = 0;

  }

  return result;

}

void outputStream::do_vsnprintf_and_write_with_automatic_buffer(const char* format, va_list ap, bool add_cr) {

  char buffer[O_BUFLEN];

  size_t len;

  const char* str = do_vsnprintf(buffer, sizeof(buffer), format, ap, add_cr, len);

  write(str, len);

}

void outputStream::do_vsnprintf_and_write_with_scratch_buffer(const char* format, va_list ap, bool add_cr) {

  size_t len;

  const char* str = do_vsnprintf(_scratch, _scratch_len, format, ap, add_cr, len);

  write(str, len);

}

void outputStream::do_vsnprintf_and_write(const char* format, va_list ap, bool add_cr) {

  if (_scratch) {

    do_vsnprintf_and_write_with_scratch_buffer(format, ap, add_cr);

  } else {

    do_vsnprintf_and_write_with_automatic_buffer(format, ap, add_cr);

  }

}

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

  va_list ap;

  va_start(ap, format);

  do_vsnprintf_and_write(format, ap, false);

  va_end(ap);

}

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

  va_list ap;

  va_start(ap, format);

  do_vsnprintf_and_write(format, ap, true);

  va_end(ap);

}

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

  do_vsnprintf_and_write(format, argptr, false);

}

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

  do_vsnprintf_and_write(format, argptr, true);

}

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;

}

outputStream& outputStream::indent() {

  while (_position < _indentation) sp();

  return *this;

}

void outputStream::print_jlong(jlong value) {

  print(JLONG_FORMAT, value);

}

void outputStream::print_julong(julong value) {

  print(JULONG_FORMAT, value);

}

/**

 * This prints out hex data in a 'windbg' or 'xxd' form, where each line is:

 *   <hex-address>: 8 * <hex-halfword> <ascii translation (optional)>

 * example:

 * 0000000: 7f44 4f46 0102 0102 0000 0000 0000 0000  .DOF............

 * 0000010: 0000 0000 0000 0040 0000 0020 0000 0005  .......@... ....

 * 0000020: 0000 0000 0000 0040 0000 0000 0000 015d  .......@.......]

 * ...

 *

 * indent is applied to each line.  Ends with a CR.

 */

void outputStream::print_data(void* data, size_t len, bool with_ascii) {

  size_t limit = (len + 16) / 16 * 16;

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

    if (i % 16 == 0) {

      indent().print(INTPTR_FORMAT_W(07) ":", i);

    }

    if (i % 2 == 0) {

      print(" ");

    }

    if (i < len) {

      print("%02x", ((unsigned char*)data)[i]);

    } else {

      print("  ");

    }

    if ((i + 1) % 16 == 0) {

      if (with_ascii) {

        print("  ");

        for (size_t j = 0; j < 16; ++j) {

          size_t idx = i + j - 15;

          if (idx < len) {

            char c = ((char*)data)[idx];

            print("%c", c >= 32 && c <= 126 ? c : '.');

          }

        }

      }

      cr();

    }

  }

}

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

  buffer_length = initial_size;

  buffer        = NEW_RESOURCE_ARRAY(char, buffer_length);

  buffer_pos    = 0;

  buffer_fixed  = false;

  DEBUG_ONLY(rm = Thread::current()->current_resource_mark();)

}

// 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;

      assert(rm == NULL || Thread::current()->current_resource_mark() == rm,

             "StringStream is re-allocated with a different ResourceMark. Current: "

             PTR_FORMAT " original: " PTR_FORMAT,

             p2i(Thread::current()->current_resource_mark()), p2i(rm));

      buffer = NEW_RESOURCE_ARRAY(char, end);

      if (buffer_pos > 0) {

        memcpy(buffer, oldbuf, buffer_pos);

      }

      buffer_length = end;

    }

  }

  // invariant: buffer is always null-terminated

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

  if (write_len > 0) {

    buffer[buffer_pos + write_len] = 0;

    memcpy(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;

CDS_ONLY(fileStream* classlist_file;) // Only dump the classes that can be stored into the CDS archive

extern Mutex* tty_lock;

#define EXTRACHARLEN   32

#define CURRENTAPPX    ".current"

// convert YYYY-MM-DD HH:MM:SS to YYYY-MM-DD_HH-MM-SS

char* get_datetime_string(char *buf, size_t len) {

  os::local_time_string(buf, len);

  int i = (int)strlen(buf);

  while (--i >= 0) {

    if (buf[i] == ' ') buf[i] = '_';

    else if (buf[i] == ':') buf[i] = '-';

  }

  return buf;

}

static const char* make_log_name_internal(const char* log_name, const char* force_directory,

                                                int pid, const char* tms) {

  const char* basename = log_name;

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

  const char* cp;

  char  pid_text[32];

  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* pts = strstr(basename, "%p");

  int pid_pos = (pts == NULL) ? -1 : (pts - nametail);

  if (pid_pos >= 0) {

    jio_snprintf(pid_text, sizeof(pid_text), "pid%u", pid);

    buffer_length += strlen(pid_text);

  }

  pts = strstr(basename, "%t");

  int tms_pos = (pts == NULL) ? -1 : (pts - nametail);

  if (tms_pos >= 0) {

    buffer_length += strlen(tms);

  }

  // File name is too long.

  if (buffer_length > JVM_MAXPATHLEN) {

    return NULL;

  }

  // Create big enough buffer.

  char *buf = NEW_C_HEAP_ARRAY(char, buffer_length, mtInternal);

  strcpy(buf, "");

  if (force_directory != NULL) {

    strcat(buf, force_directory);

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

    nametail = basename;       // completely skip directory prefix

  }

  // who is first, %p or %t?

  int first = -1, second = -1;

  const char *p1st = NULL;

  const char *p2nd = NULL;

  if (pid_pos >= 0 && tms_pos >= 0) {

    // contains both %p and %t

    if (pid_pos < tms_pos) {

      // case foo%pbar%tmonkey.log

      first  = pid_pos;

      p1st   = pid_text;

      second = tms_pos;

      p2nd   = tms;

    } else {

      // case foo%tbar%pmonkey.log

      first  = tms_pos;

      p1st   = tms;

      second = pid_pos;

      p2nd   = pid_text;

    }

  } else if (pid_pos >= 0) {

    // contains %p only

    first  = pid_pos;

    p1st   = pid_text;

  } else if (tms_pos >= 0) {

    // contains %t only

    first  = tms_pos;

    p1st   = tms;

  }

  int buf_pos = (int)strlen(buf);

  const char* tail = nametail;

  if (first >= 0) {

    tail = nametail + first + 2;

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

    strcpy(&buf[buf_pos + first], p1st);

    buf_pos = (int)strlen(buf);

    if (second >= 0) {

      strncpy(&buf[buf_pos], tail, second - first - 2);

      strcpy(&buf[buf_pos + second - first - 2], p2nd);

      tail = nametail + second + 2;

    }

  }

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

  return buf;

}

// log_name comes from -XX:LogFile=log_name or

// -XX:DumpLoadedClassList=<file_name>

// in log_name, %p => pid1234 and

//              %t => YYYY-MM-DD_HH-MM-SS

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

  char timestr[32];

  get_datetime_string(timestr, sizeof(timestr));

  return make_log_name_internal(log_name, force_directory, os::current_process_id(),

                                timestr);

}

fileStream::fileStream(const char* file_name) {

  _file = fopen(file_name, "w");

  if (_file != NULL) {

    _need_close = true;