234 lines
10 KiB
Rust
234 lines
10 KiB
Rust
//! Module containing error definitions for the evaluation process.
|
|
|
|
use crate::any::Dynamic;
|
|
use crate::error::ParseError;
|
|
use crate::parser::{Position, INT};
|
|
use std::{error::Error, fmt};
|
|
|
|
/// Evaluation result.
|
|
///
|
|
/// All wrapped `Position` values represent the location in the script where the error occurs.
|
|
#[derive(Debug)]
|
|
pub enum EvalAltResult {
|
|
/// Syntax error.
|
|
ErrorParsing(ParseError),
|
|
/// Call to an unknown function. Wrapped value is the name of the function.
|
|
ErrorFunctionNotFound(String, Position),
|
|
/// Function call has incorrect number of arguments.
|
|
/// Wrapped values are the name of the function, the number of parameters required
|
|
/// and the actual number of arguments passed.
|
|
ErrorFunctionArgsMismatch(String, usize, usize, Position),
|
|
/// Non-boolean operand encountered for boolean operator. Wrapped value is the operator.
|
|
ErrorBooleanArgMismatch(String, Position),
|
|
/// Non-character value encountered where a character is required.
|
|
ErrorCharMismatch(Position),
|
|
/// Array access out-of-bounds.
|
|
/// Wrapped values are the current number of elements in the array and the index number.
|
|
ErrorArrayBounds(usize, INT, Position),
|
|
/// String indexing out-of-bounds.
|
|
/// Wrapped values are the current number of characters in the string and the index number.
|
|
ErrorStringBounds(usize, INT, Position),
|
|
/// Trying to index into a type that is not an array and not a string.
|
|
ErrorIndexingType(String, Position),
|
|
/// Trying to index into an array or string with an index that is not `i64`.
|
|
ErrorIndexExpr(Position),
|
|
/// The guard expression in an `if` statement does not return a boolean value.
|
|
ErrorIfGuard(Position),
|
|
/// The `for` statement encounters a type that is not an iterator.
|
|
ErrorFor(Position),
|
|
/// Usage of an unknown variable. Wrapped value is the name of the variable.
|
|
ErrorVariableNotFound(String, Position),
|
|
/// Assignment to an inappropriate LHS (left-hand-side) expression.
|
|
ErrorAssignmentToUnknownLHS(Position),
|
|
/// Returned type is not the same as the required output type.
|
|
/// Wrapped value is the type of the actual result.
|
|
ErrorMismatchOutputType(String, Position),
|
|
/// Error reading from a script file. Wrapped value is the path of the script file.
|
|
ErrorReadingScriptFile(String, std::io::Error),
|
|
/// Inappropriate member access.
|
|
ErrorDotExpr(String, Position),
|
|
/// Arithmetic error encountered. Wrapped value is the error message.
|
|
ErrorArithmetic(String, Position),
|
|
/// Run-time error encountered. Wrapped value is the error message.
|
|
ErrorRuntime(String, Position),
|
|
/// Internal use: Breaking out of loops.
|
|
LoopBreak,
|
|
/// Not an error: Value returned from a script via the `return` keyword.
|
|
/// Wrapped value is the result value.
|
|
Return(Dynamic, Position),
|
|
}
|
|
|
|
impl Error for EvalAltResult {
|
|
fn description(&self) -> &str {
|
|
match self {
|
|
Self::ErrorParsing(p) => p.description(),
|
|
Self::ErrorFunctionNotFound(_, _) => "Function not found",
|
|
Self::ErrorFunctionArgsMismatch(_, _, _, _) => {
|
|
"Function call with wrong number of arguments"
|
|
}
|
|
Self::ErrorBooleanArgMismatch(_, _) => "Boolean operator expects boolean operands",
|
|
Self::ErrorCharMismatch(_) => "Character expected",
|
|
Self::ErrorIndexExpr(_) => "Indexing into an array or string expects an integer index",
|
|
Self::ErrorIndexingType(_, _) => {
|
|
"Indexing can only be performed on an array or a string"
|
|
}
|
|
Self::ErrorArrayBounds(_, index, _) if *index < 0 => {
|
|
"Array access expects non-negative index"
|
|
}
|
|
Self::ErrorArrayBounds(max, _, _) if *max == 0 => "Access of empty array",
|
|
Self::ErrorArrayBounds(_, _, _) => "Array index out of bounds",
|
|
Self::ErrorStringBounds(_, index, _) if *index < 0 => {
|
|
"Indexing a string expects a non-negative index"
|
|
}
|
|
Self::ErrorStringBounds(max, _, _) if *max == 0 => "Indexing of empty string",
|
|
Self::ErrorStringBounds(_, _, _) => "String index out of bounds",
|
|
Self::ErrorIfGuard(_) => "If guard expects boolean expression",
|
|
Self::ErrorFor(_) => "For loop expects array or range",
|
|
Self::ErrorVariableNotFound(_, _) => "Variable not found",
|
|
Self::ErrorAssignmentToUnknownLHS(_) => {
|
|
"Assignment to an unsupported left-hand side expression"
|
|
}
|
|
Self::ErrorMismatchOutputType(_, _) => "Output type is incorrect",
|
|
Self::ErrorReadingScriptFile(_, _) => "Cannot read from script file",
|
|
Self::ErrorDotExpr(_, _) => "Malformed dot expression",
|
|
Self::ErrorArithmetic(_, _) => "Arithmetic error",
|
|
Self::ErrorRuntime(_, _) => "Runtime error",
|
|
Self::LoopBreak => "[Not Error] Breaks out of loop",
|
|
Self::Return(_, _) => "[Not Error] Function returns value",
|
|
}
|
|
}
|
|
|
|
fn cause(&self) -> Option<&dyn Error> {
|
|
None
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for EvalAltResult {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let desc = self.description();
|
|
|
|
match self {
|
|
Self::ErrorFunctionNotFound(s, pos) => write!(f, "{}: '{}' ({})", desc, s, pos),
|
|
Self::ErrorVariableNotFound(s, pos) => write!(f, "{}: '{}' ({})", desc, s, pos),
|
|
Self::ErrorIndexingType(_, pos) => write!(f, "{} ({})", desc, pos),
|
|
Self::ErrorIndexExpr(pos) => write!(f, "{} ({})", desc, pos),
|
|
Self::ErrorIfGuard(pos) => write!(f, "{} ({})", desc, pos),
|
|
Self::ErrorFor(pos) => write!(f, "{} ({})", desc, pos),
|
|
Self::ErrorAssignmentToUnknownLHS(pos) => write!(f, "{} ({})", desc, pos),
|
|
Self::ErrorMismatchOutputType(s, pos) => write!(f, "{}: {} ({})", desc, s, pos),
|
|
Self::ErrorDotExpr(s, pos) if !s.is_empty() => write!(f, "{} {} ({})", desc, s, pos),
|
|
Self::ErrorDotExpr(_, pos) => write!(f, "{} ({})", desc, pos),
|
|
Self::ErrorArithmetic(s, pos) => write!(f, "{} ({})", s, pos),
|
|
Self::ErrorRuntime(s, pos) => {
|
|
write!(f, "{} ({})", if s.is_empty() { desc } else { s }, pos)
|
|
}
|
|
Self::LoopBreak => write!(f, "{}", desc),
|
|
Self::Return(_, pos) => write!(f, "{} ({})", desc, pos),
|
|
Self::ErrorReadingScriptFile(filename, err) => {
|
|
write!(f, "{} '{}': {}", desc, filename, err)
|
|
}
|
|
Self::ErrorParsing(p) => write!(f, "Syntax error: {}", p),
|
|
Self::ErrorFunctionArgsMismatch(fun, need, n, pos) => write!(
|
|
f,
|
|
"Function '{}' expects {} argument(s) but {} found ({})",
|
|
fun, need, n, pos
|
|
),
|
|
Self::ErrorBooleanArgMismatch(op, pos) => {
|
|
write!(f, "{} operator expects boolean operands ({})", op, pos)
|
|
}
|
|
Self::ErrorCharMismatch(pos) => {
|
|
write!(f, "string indexing expects a character value ({})", pos)
|
|
}
|
|
Self::ErrorArrayBounds(_, index, pos) if *index < 0 => {
|
|
write!(f, "{}: {} < 0 ({})", desc, index, pos)
|
|
}
|
|
Self::ErrorArrayBounds(max, _, pos) if *max == 0 => write!(f, "{} ({})", desc, pos),
|
|
Self::ErrorArrayBounds(max, index, pos) => write!(
|
|
f,
|
|
"Array index {} is out of bounds: only {} element{} in the array ({})",
|
|
index,
|
|
max,
|
|
if *max > 1 { "s" } else { "" },
|
|
pos
|
|
),
|
|
Self::ErrorStringBounds(_, index, pos) if *index < 0 => {
|
|
write!(f, "{}: {} < 0 ({})", desc, index, pos)
|
|
}
|
|
Self::ErrorStringBounds(max, _, pos) if *max == 0 => write!(f, "{} ({})", desc, pos),
|
|
Self::ErrorStringBounds(max, index, pos) => write!(
|
|
f,
|
|
"String index {} is out of bounds: only {} character{} in the string ({})",
|
|
index,
|
|
max,
|
|
if *max > 1 { "s" } else { "" },
|
|
pos
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<ParseError> for EvalAltResult {
|
|
fn from(err: ParseError) -> Self {
|
|
Self::ErrorParsing(err)
|
|
}
|
|
}
|
|
|
|
impl<T: AsRef<str>> From<T> for EvalAltResult {
|
|
fn from(err: T) -> Self {
|
|
Self::ErrorRuntime(err.as_ref().to_string(), Position::none())
|
|
}
|
|
}
|
|
|
|
impl EvalAltResult {
|
|
pub fn position(&self) -> Position {
|
|
match self {
|
|
Self::ErrorReadingScriptFile(_, _) | Self::LoopBreak => Position::none(),
|
|
|
|
Self::ErrorParsing(err) => err.position(),
|
|
|
|
Self::ErrorFunctionNotFound(_, pos)
|
|
| Self::ErrorFunctionArgsMismatch(_, _, _, pos)
|
|
| Self::ErrorBooleanArgMismatch(_, pos)
|
|
| Self::ErrorCharMismatch(pos)
|
|
| Self::ErrorArrayBounds(_, _, pos)
|
|
| Self::ErrorStringBounds(_, _, pos)
|
|
| Self::ErrorIndexingType(_, pos)
|
|
| Self::ErrorIndexExpr(pos)
|
|
| Self::ErrorIfGuard(pos)
|
|
| Self::ErrorFor(pos)
|
|
| Self::ErrorVariableNotFound(_, pos)
|
|
| Self::ErrorAssignmentToUnknownLHS(pos)
|
|
| Self::ErrorMismatchOutputType(_, pos)
|
|
| Self::ErrorDotExpr(_, pos)
|
|
| Self::ErrorArithmetic(_, pos)
|
|
| Self::ErrorRuntime(_, pos)
|
|
| Self::Return(_, pos) => *pos,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_position(&mut self, new_position: Position) {
|
|
match self {
|
|
Self::ErrorReadingScriptFile(_, _) | Self::LoopBreak => (),
|
|
|
|
Self::ErrorParsing(ParseError(_, ref mut pos))
|
|
| Self::ErrorFunctionNotFound(_, ref mut pos)
|
|
| Self::ErrorFunctionArgsMismatch(_, _, _, ref mut pos)
|
|
| Self::ErrorBooleanArgMismatch(_, ref mut pos)
|
|
| Self::ErrorCharMismatch(ref mut pos)
|
|
| Self::ErrorArrayBounds(_, _, ref mut pos)
|
|
| Self::ErrorStringBounds(_, _, ref mut pos)
|
|
| Self::ErrorIndexingType(_, ref mut pos)
|
|
| Self::ErrorIndexExpr(ref mut pos)
|
|
| Self::ErrorIfGuard(ref mut pos)
|
|
| Self::ErrorFor(ref mut pos)
|
|
| Self::ErrorVariableNotFound(_, ref mut pos)
|
|
| Self::ErrorAssignmentToUnknownLHS(ref mut pos)
|
|
| Self::ErrorMismatchOutputType(_, ref mut pos)
|
|
| Self::ErrorDotExpr(_, ref mut pos)
|
|
| Self::ErrorArithmetic(_, ref mut pos)
|
|
| Self::ErrorRuntime(_, ref mut pos)
|
|
| Self::Return(_, ref mut pos) => *pos = new_position,
|
|
}
|
|
}
|
|
}
|