use std::io::Write;
use std::sync::{Mutex, MutexGuard};
const DEFAULT_BUFFER_SIZE: usize = 128 * 1024;
const MAX_BLKSIZE: usize = 8 * 1024 * 1024;
const CHUNK_SIZE: usize = 8192;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Stream {
Stdout,
Stderr,
}
struct TextStream {
fd: i32,
configured: bool,
line_buffering: bool,
write_through: bool,
pending: Vec<u8>,
buffer: Vec<u8>,
buffer_size: usize,
}
static STDOUT: Mutex<TextStream> = Mutex::new(TextStream::new(1));
static STDERR: Mutex<TextStream> = Mutex::new(TextStream::new(2));
impl TextStream {
const fn new(fd: i32) -> Self {
TextStream {
fd,
configured: false,
line_buffering: false,
write_through: false,
pending: Vec::new(),
buffer: Vec::new(),
buffer_size: 0,
}
}
fn configure(&mut self) {
if self.configured {
return;
}
self.configured = true;
let buffered = std::env::var_os("PYTHONUNBUFFERED").map_or(true, |v| v.is_empty());
let isatty = unsafe { libc::isatty(self.fd) == 1 };
self.write_through = !buffered;
self.line_buffering = buffered && (isatty || self.fd == 2);
self.buffer_size = if buffered {
buffer_size_for(self.fd)
} else {
0
};
}
fn write(&mut self, bytes: &[u8]) {
self.configure();
let needflush = self.line_buffering && bytes.iter().any(|&b| b == b'\n' || b == b'\r');
if bytes.len() >= CHUNK_SIZE {
self.write_pending();
}
self.pending.extend_from_slice(bytes);
if self.pending.len() >= CHUNK_SIZE || needflush || self.write_through {
self.write_pending();
}
if needflush {
self.flush_buffer();
}
}
fn flush(&mut self) {
self.configure();
self.write_pending();
self.flush_buffer();
}
fn write_pending(&mut self) {
if self.pending.is_empty() {
return;
}
let data = std::mem::take(&mut self.pending);
self.buffered_write(&data);
}
fn buffered_write(&mut self, data: &[u8]) {
if self.buffer_size == 0 {
raw_write(self.fd, data);
return;
}
let avail = self.buffer_size - self.buffer.len();
if data.len() <= avail && data.len() < self.buffer_size {
self.buffer.extend_from_slice(data);
return;
}
self.flush_buffer();
if data.len() >= self.buffer_size {
raw_write(self.fd, data);
} else {
self.buffer.extend_from_slice(data);
}
}
fn flush_buffer(&mut self) {
if self.buffer.is_empty() {
return;
}
let data = std::mem::take(&mut self.buffer);
raw_write(self.fd, &data);
}
}
fn buffer_size_for(fd: i32) -> usize {
let blksize = unsafe {
let mut st: libc::stat = std::mem::zeroed();
if libc::fstat(fd, &mut st) == 0 && st.st_blksize > 1 {
st.st_blksize as usize
} else {
DEFAULT_BUFFER_SIZE
}
};
blksize.clamp(DEFAULT_BUFFER_SIZE, MAX_BLKSIZE)
}
fn raw_write(fd: i32, data: &[u8]) {
if fd == 2 {
let mut e = std::io::stderr().lock();
let _ = e.write_all(data);
let _ = e.flush();
} else {
let mut o = std::io::stdout().lock();
let _ = o.write_all(data);
let _ = o.flush();
}
}
fn lock(stream: Stream) -> MutexGuard<'static, TextStream> {
let m = match stream {
Stream::Stdout => &STDOUT,
Stream::Stderr => &STDERR,
};
m.lock().unwrap_or_else(|p| p.into_inner())
}
pub fn write(stream: Stream, s: &str) {
lock(stream).write(s.as_bytes());
}
pub fn write_bytes(stream: Stream, bytes: &[u8]) {
lock(stream).write(bytes);
}
pub fn flush(stream: Stream) {
lock(stream).flush();
}
pub fn flush_io() {
flush(Stream::Stderr);
flush(Stream::Stdout);
}
pub fn flush_std_files() {
flush(Stream::Stdout);
flush(Stream::Stderr);
}
pub fn set_write_through() {
for stream in [Stream::Stdout, Stream::Stderr] {
let mut s = lock(stream);
s.flush();
s.write_through = true;
s.line_buffering = false;
s.buffer_size = 0;
}
}