blob: ce622c2c28223445fde2605e8b5c0ebf871c6f34 [file]
/*
* 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