277 lines
6.8 KiB
Rust
277 lines
6.8 KiB
Rust
use std::fmt::Display;
|
|
|
|
use crate::parse::lex::Span;
|
|
use crate::prelude::*;
|
|
|
|
pub type ShResult<T> = Result<T,ShErr>;
|
|
|
|
pub trait ResultExt {
|
|
fn eprint(self) -> Self;
|
|
fn abort_if_err(&self);
|
|
}
|
|
|
|
#[derive(Clone,Debug)]
|
|
pub struct BlamePair {
|
|
input: String,
|
|
span: Rc<RefCell<Span>>
|
|
}
|
|
|
|
impl BlamePair {
|
|
pub fn new(input: String, span: Rc<RefCell<Span>>) -> Self {
|
|
Self { input, span }
|
|
}
|
|
pub fn start(&self) -> usize {
|
|
self.span.borrow().start()
|
|
}
|
|
pub fn end(&self) -> usize {
|
|
self.span.borrow().end()
|
|
}
|
|
pub fn len(&self) -> usize {
|
|
self.input.len()
|
|
}
|
|
}
|
|
|
|
impl Into<String> for BlamePair {
|
|
fn into(self) -> String {
|
|
self.input
|
|
}
|
|
}
|
|
|
|
impl<T, E: Display> ResultExt for Result<T, E> {
|
|
fn eprint(self) -> Self {
|
|
if let Err(err) = &self {
|
|
eprintln!("{}", err);
|
|
}
|
|
self
|
|
}
|
|
fn abort_if_err(&self) {
|
|
if let Err(err) = &self {
|
|
eprintln!("{}", err);
|
|
sh_quit(1)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait Blame {
|
|
/// Blame a span for a propagated error. This will convert a ShErr::Simple into a ShErr::Full
|
|
/// This will also set the span on a ShErr::Builder
|
|
fn blame(self, input: String, span: Rc<RefCell<Span>>) -> Self;
|
|
|
|
/// If an error is propagated to this point, then attempt to blame a span.
|
|
/// If the error in question has already blamed a span, don't overwrite it.
|
|
/// Used as a last resort in higher level contexts in case an error somehow goes unblamed
|
|
fn try_blame(self, input: String, span: Rc<RefCell<Span>>) -> Self;
|
|
}
|
|
|
|
impl From<std::io::Error> for ShErr {
|
|
fn from(_: std::io::Error) -> Self {
|
|
ShErr::io()
|
|
}
|
|
}
|
|
|
|
impl From<std::env::VarError> for ShErr {
|
|
fn from(value: std::env::VarError) -> Self {
|
|
ShErr::simple(ShErrKind::InternalErr, &value.to_string())
|
|
}
|
|
}
|
|
|
|
impl From<rustyline::error::ReadlineError> for ShErr {
|
|
fn from(value: rustyline::error::ReadlineError) -> Self {
|
|
ShErr::simple(ShErrKind::ParseErr, &value.to_string())
|
|
}
|
|
}
|
|
|
|
impl From<Errno> for ShErr {
|
|
fn from(value: Errno) -> Self {
|
|
ShErr::simple(ShErrKind::Errno, &value.to_string())
|
|
}
|
|
}
|
|
|
|
impl<T> Blame for Result<T,ShErr> {
|
|
fn blame(self, input: String, span: Rc<RefCell<Span>>) -> Self {
|
|
if let Err(mut e) = self {
|
|
e.blame(input,span);
|
|
Err(e)
|
|
} else {
|
|
self
|
|
}
|
|
}
|
|
fn try_blame(self, input: String, span: Rc<RefCell<Span>>) -> Self {
|
|
if let Err(mut e) = self {
|
|
e.try_blame(input,span);
|
|
Err(e)
|
|
} else {
|
|
self
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug,Copy,Clone,PartialEq,Eq)]
|
|
pub enum ShErrKind {
|
|
IoErr,
|
|
SyntaxErr,
|
|
ParseErr,
|
|
InternalErr,
|
|
ExecFail,
|
|
Errno,
|
|
CmdNotFound,
|
|
CleanExit,
|
|
FuncReturn,
|
|
LoopContinue,
|
|
LoopBreak,
|
|
Null
|
|
}
|
|
|
|
impl Default for ShErrKind {
|
|
fn default() -> Self {
|
|
Self::Null
|
|
}
|
|
}
|
|
|
|
#[derive(Clone,Debug)]
|
|
pub enum ShErr {
|
|
Simple { kind: ShErrKind, message: String },
|
|
Full { kind: ShErrKind, message: String, blame: BlamePair },
|
|
}
|
|
|
|
impl ShErr {
|
|
pub fn simple<S: Into<String>>(kind: ShErrKind, message: S) -> Self {
|
|
Self::Simple { kind, message: message.into() }
|
|
}
|
|
pub fn io() -> Self {
|
|
io::Error::last_os_error().into()
|
|
}
|
|
pub fn full<S: Into<String>>(kind: ShErrKind, message: S, input: String, span: Rc<RefCell<Span>>) -> Self {
|
|
let blame = BlamePair::new(input.to_string(), span);
|
|
Self::Full { kind, message: message.into(), blame }
|
|
}
|
|
pub fn try_blame(&mut self, input: String, span: Rc<RefCell<Span>>) {
|
|
let blame_pair = BlamePair::new(input, span);
|
|
match self {
|
|
Self::Full {..} => {
|
|
/* Do not overwrite */
|
|
}
|
|
Self::Simple { kind, message } => {
|
|
*self = Self::Full { kind: core::mem::take(kind), message: core::mem::take(message), blame: blame_pair }
|
|
}
|
|
}
|
|
}
|
|
pub fn blame(&mut self, input: String, span: Rc<RefCell<Span>>) {
|
|
let blame_pair = BlamePair::new(input, span);
|
|
match self {
|
|
Self::Full { kind: _, message: _, blame } => {
|
|
*blame = blame_pair;
|
|
}
|
|
Self::Simple { kind, message } => {
|
|
*self = Self::Full { kind: core::mem::take(kind), message: core::mem::take(message), blame: blame_pair }
|
|
}
|
|
}
|
|
}
|
|
pub fn with_msg(&mut self, new_message: String) {
|
|
match self {
|
|
Self::Full { kind: _, message, blame: _ } => {
|
|
*message = new_message
|
|
}
|
|
Self::Simple { kind: _, message } => {
|
|
*message = new_message
|
|
}
|
|
}
|
|
}
|
|
pub fn kind(&self) -> ShErrKind {
|
|
match self {
|
|
ShErr::Simple { kind, message: _ } => {
|
|
*kind
|
|
}
|
|
ShErr::Full { kind, message: _, blame: _ } => {
|
|
*kind
|
|
}
|
|
}
|
|
}
|
|
pub fn with_kind(&mut self, new_kind: ShErrKind) {
|
|
match self {
|
|
Self::Full { kind, message: _, blame: _ } => {
|
|
*kind = new_kind
|
|
}
|
|
Self::Simple { kind, message: _ } => {
|
|
*kind = new_kind
|
|
}
|
|
}
|
|
}
|
|
pub fn display_kind(&self) -> String {
|
|
match self {
|
|
ShErr::Simple { kind, message: _ } |
|
|
ShErr::Full { kind, message: _, blame: _ } => {
|
|
match kind {
|
|
ShErrKind::IoErr => "I/O Error: ".into(),
|
|
ShErrKind::SyntaxErr => "Syntax Error: ".into(),
|
|
ShErrKind::ParseErr => "Parse Error: ".into(),
|
|
ShErrKind::InternalErr => "Internal Error: ".into(),
|
|
ShErrKind::ExecFail => "Execution Failed: ".into(),
|
|
ShErrKind::Errno => "ERRNO: ".into(),
|
|
ShErrKind::CmdNotFound => "Command not found: ".into(),
|
|
ShErrKind::CleanExit |
|
|
ShErrKind::FuncReturn |
|
|
ShErrKind::LoopContinue |
|
|
ShErrKind::LoopBreak |
|
|
ShErrKind::Null => "".into()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pub fn get_line(&self) -> (usize,usize,String) {
|
|
if let ShErr::Full { kind: _, message: _, blame } = self {
|
|
unsafe {
|
|
let mut dist = 0;
|
|
let mut line_no = 0;
|
|
let window = self.get_window();
|
|
let mut lines = window.lines();
|
|
while let Some(line) = lines.next() {
|
|
line_no += 1;
|
|
dist += line.len();
|
|
if dist > blame.start() {
|
|
dist -= line.len();
|
|
let offset = blame.start() - dist;
|
|
return (offset,line_no,line.to_string())
|
|
}
|
|
}
|
|
}
|
|
(0,0,String::new())
|
|
} else {
|
|
(0,0,String::new())
|
|
}
|
|
}
|
|
pub fn get_window(&self) -> String {
|
|
if let ShErr::Full { kind: _, message: _, blame } = self.clone() {
|
|
let window: String = blame.into();
|
|
window.split_once('\n').unwrap_or((&window,"")).0.to_string()
|
|
} else {
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for ShErr {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
let error_display = match self {
|
|
ShErr::Simple { kind: _, message } => format!("{}{}",self.display_kind(),message),
|
|
ShErr::Full { kind: _, message, blame } => {
|
|
let (offset,line_no,line_text) = self.get_line();
|
|
let dist = blame.end().saturating_sub(blame.start());
|
|
let padding = " ".repeat(offset);
|
|
let line_inner = "~".repeat(dist.saturating_sub(2));
|
|
let err_kind = &self.display_kind().styled(Style::Red | Style::Bold);
|
|
let stat_line = format!("[{}:{}] - {}{}",line_no,offset,err_kind,message);
|
|
let indicator_line = if dist == 1 {
|
|
format!("{}^",padding)
|
|
} else {
|
|
format!("{}^{}^",padding,line_inner)
|
|
};
|
|
let error_full = format!("\n{}\n{}\n{}\n",stat_line,line_text,indicator_line);
|
|
|
|
error_full
|
|
}
|
|
};
|
|
write!(f,"{}",error_display)
|
|
}
|
|
}
|