use crate::codegen_runtime::{NifReturnable, NifReturned};
use crate::types::atom;
use crate::{types, Encoder, Env};
use std::fmt;
pub enum Error {
BadArg,
Atom(&'static str),
RaiseAtom(&'static str),
RaiseTerm(Box<dyn Encoder>),
Term(Box<dyn Encoder>),
}
unsafe impl NifReturnable for crate::error::Error {
unsafe fn into_returned(self, env: Env) -> NifReturned {
match self {
Error::BadArg => NifReturned::BadArg,
Error::Atom(atom_str) => {
let atom = types::atom::Atom::from_str(env, atom_str)
.expect("Error::Atom: bad atom")
.to_term(env);
NifReturned::Term(atom.as_c_arg())
}
Error::RaiseAtom(atom_str) => {
let atom = types::atom::Atom::from_str(env, atom_str)
.expect("Error::RaiseAtom: bad argument");
NifReturned::Raise(atom.as_c_arg())
}
Error::RaiseTerm(ref term_unencoded) => {
let term = term_unencoded.encode(env);
NifReturned::Raise(term.as_c_arg())
}
Error::Term(ref term_unencoded) => {
let term = term_unencoded.encode(env);
let error_tuple = (atom::error(), term).encode(env);
NifReturned::Term(error_tuple.as_c_arg())
}
}
}
}
impl fmt::Debug for Error {
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match self {
Error::BadArg => write!(fmt, "{{error, badarg}}"),
Error::Atom(ref s) => write!(fmt, "{{error, {}}}", s),
Error::RaiseAtom(ref s) => write!(fmt, "throw({})", s),
Error::RaiseTerm(_) => write!(fmt, "throw(<term>)"),
Error::Term(_) => write!(fmt, "{{error, {{:error, <term>}}}}"),
}
}
}