/*
 * Copyright (c) 2024, 2025, 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 "memory/allocation.inline.hpp"
#include "runtime/orderAccess.hpp"
#include "utilities/istream.hpp"
#include "utilities/ostream.hpp"
#include "utilities/xmlstream.hpp"

#ifndef ASSERT
#define COV(casen) {}
#else //ASSERT
// Support for coverage testing.  Used by the gtest.
/* $ sed < istream.cpp '/^.* COV(\([A-Z][^)]*\)).*$/!d;s//COV_FN(\1)/' |
     tr '\12' ' ' | fold -sw72 | sed 's| $||;s|.*|  & \\|'
  */
#define DO_COV_CASES(COV_FN) \
  COV_FN(NXT_L) COV_FN(NXT_N) COV_FN(FIB_P) COV_FN(FIB_E) COV_FN(FIB_N) \
  COV_FN(FIB_L) COV_FN(PFB_C) COV_FN(PFB_P) COV_FN(PFB_A) \
  COV_FN(PFB_G) COV_FN(PFB_H) COV_FN(SBC_C) COV_FN(SBC_B) COV_FN(SBC_N) \
  COV_FN(SBC_L) COV_FN(EXB_R) COV_FN(EXB_A)
  /**/
#define COV_COUNT(casename) coverage_case_##casename
#define DECLARE_COV_CASE(casename) static int COV_COUNT(casename);
DO_COV_CASES(DECLARE_COV_CASE)
#undef DECLARE_COV_CASE

static int current_coverage_mode = 0;
#define COV(casename) {                                 \
    if (current_coverage_mode != 0) {                   \
      COV_COUNT(casename)++;                            \
    }                                                  }
#endif //ASSERT

bool inputStream::next() {
  // We have to look at the current line first, just in case nobody
  // actually called current_line() or done().
  preload();
  if (definitely_done()) {
    return false;         // OK to call this->next() after done is true
  }
  // current line is at buffer[beg..end]; now skip past its '\0'
  assert(have_current_line(), "");

  set_buffer_content(_next, _content_end);
  if (!need_to_read()) {  // any next line was already in the buffer
    COV(NXT_L);
    assert(have_current_line(), "");
    return true;
  } else {                // go back to the source for more
    COV(NXT_N);
    return fill_buffer();
  }
}

void inputStream::set_done() {
  size_t end = _beg = _end = _content_end;
  _next = end + NEXT_PHANTOM;
  assert(definitely_done(), "");
}

void inputStream::set_error(bool error_condition) {
  if (error_condition) {
    set_done();
    _input_state = IState::ERR_STATE;
    assert(error(), "");
  } else if (error()) {
    _input_state = definitely_done() ? IState::EOF_STATE : IState::NTR_STATE;
  }
}

void inputStream::clear_buffer() {
  _content_end = _beg = _end = _next = 0;
}

const char* inputStream::next_content(size_t& next_content_length) const {
  assert(is_sane(), "");
  size_t len = buffered_content_length(false);
  next_content_length = len;
  return len == 0 ? "" : &_buffer[_next];
}

void inputStream::set_input(inputStream::Input* input) {
  clear_buffer();
  _input = input;
  _input_state = IState::NTR_STATE;
}

bool inputStream::fill_buffer() {
  size_t fill_offset, fill_length;
  assert(!definitely_done(), "");  // caller responsibility
  while (need_to_read()) {
    prepare_to_fill_buffer(fill_offset, fill_length);
    if (error())  return false;
    assert(fill_length > 0, "");
    assert(fill_offset < _buffer_size, "");
    assert(fill_offset + fill_length <= _buffer_size, "");
    size_t nr = 0;
    if (_input != nullptr && _input_state == IState::NTR_STATE) {
      nr = _input->read(&_buffer[fill_offset], fill_length);
      if (nr == 0)  _input_state = IState::EOF_STATE;  // do not get EOF twice
    }
    bool last_partial = false;
    if (nr > 0) {
      fill_offset += nr;
    } else if (_beg == _end) {  // no partial line, so end it now
      // we hit the end of the file (or there was never anything there)
      COV(FIB_P);
      assert(!definitely_done(), "");
      set_done();
      assert(definitely_done(), "");
      return false;
    } else {
      // pretend to read a newline, to complete the last partial line
      COV(FIB_E);
      _buffer[fill_offset++] = '\n';  // insert phantom newline
      last_partial = true;
    }
    set_buffer_content(_beg, fill_offset);
    assert(!definitely_done(), "");
    if (need_to_read()) { COV(FIB_N); }
    else                { COV(FIB_L); }
    if (last_partial) {
      assert(have_current_line(), "");
      _content_end -= 1;  // reverse insertion of phantom newline
      assert(_next == _content_end + NEXT_PHANTOM, "");
      assert(have_current_line(), "");
    }
  }
  return true;
}

// Find some space in the buffer for reading.  If there is already a
// partial line in the buffer, new space must follow it immediately.
// The partial line is between _beg and _end, and no other parts of
// the buffer are in use.
void inputStream::prepare_to_fill_buffer(size_t& fill_offset,
                                         size_t& fill_length) {
  assert(need_to_read(), "");  // _next pointer out of the way
  size_t end = _content_end;
  if (_beg == end) { // if no partial line present...
    COV(PFB_C);
    clear_buffer();
    fill_offset = 0;
    fill_length = _buffer_size;
    return;   // use the whole buffer
  }
  // at this point we have a pending line that needs more input
  if (_beg > 0 && (_input != nullptr || end == _buffer_size)) {
    COV(PFB_P);
    // compact the buffer by overwriting characters from previous lines
    size_t shift_left = _beg;
    ::memmove(_buffer, _buffer + shift_left, _content_end - _beg);
    _beg -= shift_left;
    _end -= shift_left;
    _next -= shift_left;
    _content_end -= shift_left;
    end = _content_end;
  }
  if (end < _buffer_size) {
    COV(PFB_A);
    fill_offset = end;
    fill_length = _buffer_size - end;
    return;   // use the whole buffer except partial line at the beginning
  }
  // the whole buffer contains a partial line, which means we must expand
  COV(PFB_G);
  size_t new_size = (_buffer_size < BIG_SIZE ? BIG_SIZE
                     : _buffer_size + _buffer_size / 2);
  assert(new_size > _buffer_size, "");
  if (expand_buffer(new_size)) {
    COV(PFB_H);
    fill_offset = end;
    fill_length = _buffer_size - end;
    return;   // use the expanded buffer, except the partial line
  }
  // no recovery from failed allocation; just set the error state and bail
  set_error();
}

// The only buffer content is between the given offsets.
// Set _beg, _end, _next, and _content_end appropriately.
void inputStream::set_buffer_content(size_t content_start,
                                     size_t content_end) {
  assert(content_end <= _buffer_size, "");
  assert(content_start <= content_end + NEXT_PHANTOM, "");
  if (content_start >= content_end) {   // empty content; clear buffer
    COV(SBC_C);
    clear_buffer();
    return;
  }
  COV(SBC_B);
  size_t content_len = content_end - content_start;
  _beg = content_start;
  _content_end = content_end;

  // this is where we scan for newlines
  char* nl = (char*) memchr(&_buffer[content_start], '\n', content_len);
  if (nl == nullptr) {
    COV(SBC_N);
    _next = _end = content_end;
    assert(need_to_read(), "");
  } else {
    COV(SBC_L);
    *nl = '\0';  // so that this->current_line() will work
    ++_line_count;
    size_t end = nl - &_buffer[0];
    _next = end + 1;
    assert(_next != _content_end + NEXT_PHANTOM, "");
    if (end > content_start && nl[-1] == '\r') { // yuck
      // again, for this->current_line(), remove '\r' before '\n'
      nl[-1] = '\0';
      --end;
      // Note: we could treat '\r' alone as a line ending on some
      // platforms, but that is way too much work.  Newline '\n' is
      // supported everywhere, and some tools insist on accompanying
      // it with return as well, so we remove that.  But return '\r'
      // by itself is an obsolete format, and also inconsistent with
      // outputStream, which standarizes on '\n' and never emits '\r'.
      // Postel's law suggests that we write '\n' only and grudgingly
      // accept '\r' before '\n'.
    }
    _end = end;  // now this->current_line() points to buf[beg..end]
    assert(have_current_line(), "");
    assert(current_line() == &_buffer[_beg], "");
    assert(current_line_length() == _end - _beg, "");
  }
}

// Return true iff we expanded the buffer to the given length.
bool inputStream::expand_buffer(size_t new_length) {
  assert(new_length > _buffer_size, "");
  char* new_buf = nullptr;
  assert(new_length > sizeof(_small_buffer), "");
  if (_buffer == &_small_buffer[0]) {
    // fresh alloc from c-heap
    COV(EXB_A);
    new_buf = NEW_C_HEAP_ARRAY(char, new_length, mtInternal);
    assert(new_buf != nullptr, "would have exited VM if OOM");
    if (_content_end > 0) {
      assert(_content_end <= _buffer_size, "");
      ::memcpy(new_buf, _buffer, _content_end);  // copy only the active content
    }
  } else {
    // realloc
    COV(EXB_R);
    new_buf = REALLOC_C_HEAP_ARRAY(char, _buffer, new_length, mtInternal);
    assert(new_buf != nullptr, "would have exited VM if OOM");
  }

  if (new_buf == nullptr) {
    return false;   // do not further update _buffer etc.
  }
  _buffer = new_buf;
  _buffer_size = new_length;
  return true;
}

inputStream::~inputStream() {
  if (has_c_heap_buffer()) {
    FreeHeap(_buffer);
    DEBUG_ONLY(_buffer = (char*)((uintptr_t)0xdeadbeef)); // sanity
  }
}

#ifdef ASSERT
void inputStream::dump(const char* what) {
  int diff = (int)(_end - _beg);
  if (!_buffer || _beg > _buffer_size || _end > _buffer_size)
    diff = 0;

  bool ntr = (_next == _end),
       hcl = (_beg < _content_end && _end < _next),
       ddn = (_beg == _content_end && _next > _content_end);
  tty->print_cr("%s%sistream %s%s%s%s%s [%d<%.*s>%d/%d..%d] "
                " B=%llx%s[%d], LN=%d, CH=%d",
                what ? what : "", what ? ": " : "",
                _buffer == nullptr ? "U" : "",
                ntr ? "R" : "",
                hcl ? "L" : "",
                ddn ? "D" : "",
                (_next < _content_end ? "" :
                 _next == _content_end ? "N" : "P"),
                (int)_beg,
                diff < 0 ? 0 : diff > 10 ? 10 : diff,
                _buffer ? &_buffer[_beg] : "",
                (int)_end, (int)_next, (int)_content_end,
                (unsigned long long)(intptr_t)_buffer,
                _buffer == _small_buffer ? "(SB)" : "",
                (int)_buffer_size,
                (int)_line_count,
                has_c_heap_buffer());
  assert(is_sane(), "");
}
#endif

#ifdef ASSERT
// More support for coverage testing.
int inputStream::coverage_mode(int start,
                               int& cases, int& total, int& zeroes) {
  int old_mode = current_coverage_mode;
  current_coverage_mode = start;
  int num_cases = 0, zero_count = 0, case_count = 0;
#define COUNT_COV_CASE(casename) {              \
    int tem = COV_COUNT(casename);              \
    case_count += tem;                          \
    if (tem == 0)  ++zero_count;                \
    num_cases++;                                \
  }
  DO_COV_CASES(COUNT_COV_CASE)
#undef COUNT_COV_CASE
  if (start < 0) {
    tty->print("istream coverage:");
    #define PRINT_COV_CASE(casename) \
      tty->print(" %s:%d", #casename, COV_COUNT(casename));
    DO_COV_CASES(PRINT_COV_CASE)
    tty->cr();
    #undef PRINT_COV_CASE
    if (zero_count != 0) {
      case_count = -case_count;
      #define ZERO_COV_CASE(casename)                  \
        if (COV_COUNT(casename) == 0)                  \
          tty->print_cr("%s: no coverage for %s",      \
                        __FILE__, #casename);          \
      DO_COV_CASES(ZERO_COV_CASE)
      #undef ZERO_COV_CASE
    }
  }
  if (start >= 2 || start < 0) {
    #define CLEAR_COV_CASE(casename) \
       COV_COUNT(casename) = 0;
    DO_COV_CASES(CLEAR_COV_CASE)
    #undef CLEAR_COV_CASE
  }
  cases  = num_cases;
  total  = case_count;
  zeroes = zero_count;
  return old_mode;
}
#endif //ASSERT