611 lines
17 KiB
Rust
611 lines
17 KiB
Rust
use crate::prolog_parser::ast::*;
|
|
|
|
use crate::prolog::read::readline::*;
|
|
use crate::prolog::machine::machine_errors::*;
|
|
use crate::prolog::machine::machine_indices::*;
|
|
use crate::prolog::machine::machine_state::*;
|
|
use crate::prolog::read::PrologStream;
|
|
|
|
use std::cell::RefCell;
|
|
use std::error::Error;
|
|
use std::fmt;
|
|
use std::fs::File;
|
|
use std::io::{stdout, Cursor, ErrorKind, Read, Write};
|
|
use std::hash::{Hash, Hasher};
|
|
use std::net::TcpStream;
|
|
use std::rc::Rc;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
pub enum StreamType {
|
|
Binary,
|
|
Text,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
pub enum EOFAction {
|
|
EOFCode,
|
|
Error,
|
|
Reset,
|
|
}
|
|
|
|
/* all these streams are closed automatically when the instance is
|
|
* dropped. */
|
|
pub enum StreamInstance {
|
|
Bytes(Cursor<Vec<u8>>),
|
|
DynReadSource(Box<dyn Read>),
|
|
File(File),
|
|
Null,
|
|
ReadlineStream(ReadlineStream),
|
|
// Stdin,
|
|
Stdout,
|
|
TcpStream(TcpStream),
|
|
}
|
|
|
|
impl fmt::Debug for StreamInstance {
|
|
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
|
match self {
|
|
&StreamInstance::Bytes(ref bytes) =>
|
|
write!(fmt, "Bytes({:?})", bytes),
|
|
&StreamInstance::DynReadSource(_) =>
|
|
write!(fmt, "DynReadSource(_)"), // Hacky solution.
|
|
&StreamInstance::File(ref file) => write!(fmt, "File({:?})", file),
|
|
&StreamInstance::Null => write!(fmt, "Null"),
|
|
&StreamInstance::ReadlineStream(ref readline_stream) =>
|
|
write!(fmt, "ReadlineStream({:?})", readline_stream),
|
|
// &StreamInstance::Stdin => write!(fmt, "Stdin"),
|
|
&StreamInstance::Stdout => write!(fmt, "Stdout"),
|
|
&StreamInstance::TcpStream(ref tcp_stream) =>
|
|
write!(fmt, "TcpStream({:?})", tcp_stream),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct WrappedStreamInstance(Rc<RefCell<StreamInstance>>);
|
|
|
|
impl WrappedStreamInstance {
|
|
#[inline]
|
|
fn new(stream_inst: StreamInstance) -> Self {
|
|
WrappedStreamInstance(Rc::new(RefCell::new(stream_inst)))
|
|
}
|
|
}
|
|
|
|
impl PartialEq for WrappedStreamInstance {
|
|
#[inline]
|
|
fn eq(&self, other: &Self) -> bool {
|
|
Rc::ptr_eq(&self.0, &other.0)
|
|
}
|
|
}
|
|
|
|
impl Eq for WrappedStreamInstance {}
|
|
|
|
impl Hash for WrappedStreamInstance {
|
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
let rc = &self.0;
|
|
let ptr = Rc::into_raw(rc.clone());
|
|
|
|
state.write_usize(ptr as usize);
|
|
|
|
unsafe {
|
|
// necessary to avoid memory leak.
|
|
let _ = Rc::from_raw(ptr);
|
|
};
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
enum StreamError {
|
|
ReadFromOutputStream,
|
|
WriteToInputStream,
|
|
FlushToInputStream,
|
|
}
|
|
|
|
impl fmt::Display for StreamError {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
StreamError::ReadFromOutputStream => {
|
|
write!(f, "attempted to read from a write-only stream")
|
|
}
|
|
StreamError::WriteToInputStream => {
|
|
write!(f, "attempted to write to a read-only stream")
|
|
}
|
|
StreamError::FlushToInputStream => {
|
|
write!(f, "attempted to flush a read-only stream")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Error for StreamError {}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
|
pub struct StreamOptions {
|
|
pub stream_type: StreamType,
|
|
pub reposition: bool,
|
|
pub alias: Option<ClauseName>,
|
|
pub eof_action: EOFAction,
|
|
}
|
|
|
|
impl Default for StreamOptions {
|
|
#[inline]
|
|
fn default() -> Self {
|
|
StreamOptions {
|
|
stream_type: StreamType::Text,
|
|
reposition: false,
|
|
alias: None,
|
|
eof_action: EOFAction::EOFCode,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
|
pub struct Stream {
|
|
pub options: StreamOptions,
|
|
stream_inst: WrappedStreamInstance,
|
|
}
|
|
|
|
impl From<TcpStream> for Stream {
|
|
fn from(tcp_stream: TcpStream) -> Self {
|
|
Stream {
|
|
options: StreamOptions::default(),
|
|
stream_inst: WrappedStreamInstance::new(
|
|
StreamInstance::TcpStream(tcp_stream)
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<String> for Stream {
|
|
fn from(string: String) -> Self {
|
|
Stream {
|
|
options: StreamOptions::default(),
|
|
stream_inst: WrappedStreamInstance::new(
|
|
StreamInstance::Bytes(Cursor::new(string.into_bytes()))
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<ReadlineStream> for Stream {
|
|
fn from(rl_stream: ReadlineStream) -> Self {
|
|
Stream {
|
|
options: StreamOptions::default(),
|
|
stream_inst: WrappedStreamInstance::new(
|
|
StreamInstance::ReadlineStream(rl_stream)
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<&'static str> for Stream {
|
|
fn from(src: &'static str) -> Stream {
|
|
Stream {
|
|
options: StreamOptions::default(),
|
|
stream_inst: WrappedStreamInstance::new(
|
|
StreamInstance::DynReadSource(Box::new(src.as_bytes()))
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<File> for Stream {
|
|
fn from(file: File) -> Stream {
|
|
Stream {
|
|
options: StreamOptions::default(),
|
|
stream_inst: WrappedStreamInstance::new(
|
|
StreamInstance::File(file)
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Stream {
|
|
#[inline]
|
|
pub(crate)
|
|
fn as_ptr(&self) -> *const u8 {
|
|
let rc = self.stream_inst.0.clone();
|
|
let ptr = Rc::into_raw(rc);
|
|
|
|
unsafe {
|
|
// must be done to avoid memory leak.
|
|
let _ = Rc::from_raw(ptr);
|
|
}
|
|
|
|
ptr as *const u8
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate)
|
|
fn stdout() -> Self {
|
|
Stream {
|
|
options: StreamOptions::default(),
|
|
stream_inst: WrappedStreamInstance::new(
|
|
StreamInstance::Stdout
|
|
),
|
|
}
|
|
}
|
|
|
|
/*
|
|
#[inline]
|
|
pub(crate)
|
|
fn stdin() -> Self {
|
|
Stream {
|
|
options: StreamOptions::default(),
|
|
stream_inst: WrappedStreamInstance::new(
|
|
StreamInstance::Stdin
|
|
),
|
|
}
|
|
}
|
|
*/
|
|
|
|
#[inline]
|
|
pub(crate)
|
|
fn null_stream() -> Self {
|
|
Stream {
|
|
options: StreamOptions::default(), // TODO: null_options?
|
|
stream_inst: WrappedStreamInstance::new(
|
|
StreamInstance::Null
|
|
),
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate)
|
|
fn is_stdout(&self) -> bool {
|
|
match *self.stream_inst.0.borrow() {
|
|
StreamInstance::Stdout => {
|
|
true
|
|
}
|
|
_ => {
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate)
|
|
fn is_stdin(&self) -> bool {
|
|
match *self.stream_inst.0.borrow() {
|
|
//StreamInstance::Stdin |
|
|
StreamInstance::ReadlineStream(_) => {
|
|
true
|
|
}
|
|
_ => {
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate)
|
|
fn is_input_stream(&self) -> bool {
|
|
match *self.stream_inst.0.borrow() {
|
|
// StreamInstance::Stdin |
|
|
StreamInstance::TcpStream(_) |
|
|
StreamInstance::Bytes(_) |
|
|
StreamInstance::ReadlineStream(_) |
|
|
StreamInstance::DynReadSource(_) |
|
|
StreamInstance::File(_) => {
|
|
true
|
|
}
|
|
_ => {
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate)
|
|
fn is_output_stream(&self) -> bool {
|
|
match *self.stream_inst.0.borrow() {
|
|
StreamInstance::Stdout
|
|
| StreamInstance::TcpStream(_)
|
|
| StreamInstance::Bytes(_)
|
|
| StreamInstance::File(_) => {
|
|
true
|
|
}
|
|
_ => {
|
|
false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl MachineState {
|
|
pub(crate)
|
|
fn to_stream_options(
|
|
&self,
|
|
alias: Addr,
|
|
eof_action: Addr,
|
|
reposition: Addr,
|
|
stream_type: Addr,
|
|
) -> StreamOptions {
|
|
let alias =
|
|
match self.store(self.deref(alias)) {
|
|
Addr::Con(h) if self.heap.atom_at(h) => {
|
|
if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
|
|
Some(name.clone())
|
|
} else {
|
|
unreachable!()
|
|
}
|
|
}
|
|
_ => {
|
|
None
|
|
}
|
|
};
|
|
|
|
let eof_action =
|
|
match self.store(self.deref(eof_action)) {
|
|
Addr::Con(h) if self.heap.atom_at(h) => {
|
|
if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
|
|
match name.as_str() {
|
|
"eof_code" => EOFAction::EOFCode,
|
|
"error" => EOFAction::Error,
|
|
"reset" => EOFAction::Reset,
|
|
_ => unreachable!(),
|
|
}
|
|
} else {
|
|
unreachable!()
|
|
}
|
|
}
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
};
|
|
|
|
let reposition =
|
|
match self.store(self.deref(reposition)) {
|
|
Addr::Con(h) if self.heap.atom_at(h) => {
|
|
if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
|
|
name.as_str() == "true"
|
|
} else {
|
|
unreachable!()
|
|
}
|
|
}
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
};
|
|
|
|
let stream_type =
|
|
match self.store(self.deref(stream_type)) {
|
|
Addr::Con(h) if self.heap.atom_at(h) => {
|
|
if let HeapCellValue::Atom(ref name, _) = &self.heap[h] {
|
|
match name.as_str() {
|
|
"text" => StreamType::Text,
|
|
"binary" => StreamType::Binary,
|
|
_ => unreachable!()
|
|
}
|
|
} else {
|
|
unreachable!()
|
|
}
|
|
}
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
};
|
|
|
|
let mut options = StreamOptions::default();
|
|
|
|
options.stream_type = stream_type;
|
|
options.reposition = reposition;
|
|
options.alias = alias;
|
|
options.eof_action = eof_action;
|
|
|
|
options
|
|
}
|
|
|
|
pub(crate)
|
|
fn get_stream_or_alias(
|
|
&mut self,
|
|
addr: Addr,
|
|
indices: &IndexStore,
|
|
caller: &'static str,
|
|
arity: usize,
|
|
) -> Result<Stream, MachineStub>
|
|
{
|
|
Ok(match addr {
|
|
Addr::Con(h) if self.heap.atom_at(h) => {
|
|
if let HeapCellValue::Atom(ref atom, ref spec) = self.heap.clone(h) {
|
|
match indices.stream_aliases.get(atom) {
|
|
Some(stream) => {
|
|
stream.clone()
|
|
}
|
|
None => {
|
|
let stub = MachineError::functor_stub(clause_name!(caller), arity);
|
|
let h = self.heap.h();
|
|
|
|
let addr = self.heap.to_unifiable(
|
|
HeapCellValue::Atom(atom.clone(), spec.clone())
|
|
);
|
|
|
|
return Err(self.error_form(
|
|
MachineError::existence_error(h + 1, ExistenceError::Stream(addr)),
|
|
stub,
|
|
));
|
|
}
|
|
}
|
|
} else {
|
|
unreachable!()
|
|
}
|
|
}
|
|
Addr::Stream(h) => {
|
|
if let HeapCellValue::Stream(ref stream) = &self.heap[h] {
|
|
stream.clone()
|
|
} else {
|
|
unreachable!()
|
|
}
|
|
}
|
|
_ => {
|
|
let stub = MachineError::functor_stub(clause_name!(caller), arity);
|
|
|
|
return Err(self.error_form(
|
|
MachineError::domain_error(DomainErrorType::StreamOrAlias, addr),
|
|
stub,
|
|
));
|
|
}
|
|
})
|
|
}
|
|
|
|
pub(crate)
|
|
fn open_parsing_stream(
|
|
&self,
|
|
stream: Stream,
|
|
stub_name: &'static str,
|
|
stub_arity: usize,
|
|
) -> Result<PrologStream, MachineStub> {
|
|
match parsing_stream(stream) {
|
|
Ok(stream) => {
|
|
Ok(stream)
|
|
}
|
|
Err(e) => {
|
|
let stub = MachineError::functor_stub(clause_name!(stub_name), stub_arity);
|
|
let err = MachineError::session_error(
|
|
self.heap.h(),
|
|
SessionError::from(e),
|
|
);
|
|
|
|
Err(self.error_form(err, stub))
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate)
|
|
fn open_permission_error<T: PermissionError>(
|
|
&self,
|
|
culprit: T,
|
|
stub_name: &'static str,
|
|
stub_arity: usize,
|
|
) -> MachineStub {
|
|
let stub = MachineError::functor_stub(clause_name!(stub_name), stub_arity);
|
|
let err = MachineError::permission_error(
|
|
self.heap.h(),
|
|
Permission::Open,
|
|
"source_sink",
|
|
culprit,
|
|
);
|
|
|
|
return self.error_form(err, stub);
|
|
}
|
|
|
|
pub(crate)
|
|
fn occupied_alias_permission_error(
|
|
&self,
|
|
alias: ClauseName,
|
|
stub_name: &'static str,
|
|
stub_arity: usize,
|
|
) -> MachineStub {
|
|
let stub = MachineError::functor_stub(clause_name!(stub_name), stub_arity);
|
|
let err = MachineError::permission_error(
|
|
self.heap.h(),
|
|
Permission::Open,
|
|
"source_sink",
|
|
functor!("alias", [clause_name(alias)]),
|
|
);
|
|
|
|
return self.error_form(err, stub);
|
|
}
|
|
|
|
pub(crate)
|
|
fn reposition_error(
|
|
&self,
|
|
stub_name: &'static str,
|
|
stub_arity: usize,
|
|
) -> MachineStub {
|
|
let stub = MachineError::functor_stub(clause_name!(stub_name), stub_arity);
|
|
let rep_stub = functor!("reposition", [atom("true")]);
|
|
|
|
let err = MachineError::permission_error(
|
|
self.heap.h(),
|
|
Permission::Open,
|
|
"source_sink",
|
|
rep_stub,
|
|
);
|
|
|
|
return self.error_form(err, stub);
|
|
}
|
|
}
|
|
|
|
impl Read for Stream {
|
|
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
|
|
match *self.stream_inst.0.borrow_mut() {
|
|
StreamInstance::File(ref mut file) => {
|
|
file.read(buf)
|
|
}
|
|
StreamInstance::TcpStream(ref mut tcp_stream) => {
|
|
tcp_stream.read(buf)
|
|
}
|
|
StreamInstance::ReadlineStream(ref mut rl_stream) => {
|
|
rl_stream.read(buf)
|
|
}
|
|
StreamInstance::DynReadSource(ref mut src) => {
|
|
src.read(buf)
|
|
}
|
|
StreamInstance::Bytes(ref mut cursor) => {
|
|
cursor.read(buf)
|
|
}
|
|
/*
|
|
StreamInstance::Stdin => {
|
|
stdin().read(buf)
|
|
}
|
|
*/
|
|
StreamInstance::Stdout | StreamInstance::Null => {
|
|
Err(std::io::Error::new(
|
|
ErrorKind::PermissionDenied,
|
|
StreamError::ReadFromOutputStream,
|
|
))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Write for Stream {
|
|
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
|
|
match *self.stream_inst.0.borrow_mut() {
|
|
StreamInstance::File(ref mut file) => {
|
|
file.write(buf)
|
|
}
|
|
StreamInstance::TcpStream(ref mut tcp_stream) => {
|
|
tcp_stream.write(buf)
|
|
}
|
|
StreamInstance::Bytes(ref mut cursor) => {
|
|
cursor.write(buf)
|
|
}
|
|
StreamInstance::Stdout => {
|
|
stdout().write(buf)
|
|
}
|
|
_ => {
|
|
Err(std::io::Error::new(
|
|
ErrorKind::PermissionDenied,
|
|
StreamError::WriteToInputStream,
|
|
))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn flush(&mut self) -> std::io::Result<()> {
|
|
match *self.stream_inst.0.borrow_mut() {
|
|
StreamInstance::File(ref mut file) => {
|
|
file.flush()
|
|
}
|
|
StreamInstance::TcpStream(ref mut tcp_stream) => {
|
|
tcp_stream.flush()
|
|
}
|
|
StreamInstance::Bytes(ref mut cursor) => {
|
|
cursor.flush()
|
|
}
|
|
StreamInstance::Stdout => {
|
|
stdout().flush()
|
|
}
|
|
_ => {
|
|
Err(std::io::Error::new(
|
|
ErrorKind::PermissionDenied,
|
|
StreamError::FlushToInputStream,
|
|
))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//TODO: write a Seek instance.
|