use alloc::collections::BTreeMap;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
use crate::runtime::{Object, Runtime, RuntimeFailure, Value, put};
use crate::runtime::SharedCell;
pub(crate) const CLASSES: [(&str, &str, &str); 14] = [
("error", "Error", ""),
("memoryerror", "MemoryError", "error"),
("oserror", "OSError", "error"),
("targeterror", "TargetError", "error"),
("timeouterror", "TimeoutError", "error"),
("typeerror", "TypeError", "error"),
("unseterror", "UnsetError", "error"),
("membererror", "MemberError", "unseterror"),
("propertyerror", "PropertyError", "membererror"),
("methoderror", "MethodError", "membererror"),
("unsetitemerror", "UnsetItemError", "unseterror"),
("valueerror", "ValueError", "error"),
("indexerror", "IndexError", "valueerror"),
("zerodivisionerror", "ZeroDivisionError", "error"),
];
pub(crate) fn the_spelling_of(class: &str) -> Option<String> {
let class = class.to_lowercase();
CLASSES
.iter()
.find(|(name, _, _)| *name == class)
.map(|(_, spelled, _)| spelled.to_string())
}
pub(crate) fn the_base_of(class: &str) -> Option<&'static str> {
let class = class.to_lowercase();
CLASSES
.iter()
.find(|(name, _, _)| *name == class)
.map(|(_, _, base)| *base)
.filter(|base| !base.is_empty())
}
pub(crate) fn the_class_of(message: &str) -> &'static str {
if message == "Divide by zero." {
return "ZeroDivisionError";
}
if message.starts_with('(') {
return "OSError";
}
if message == "Target process not found." {
return "TargetError";
}
if message == "Target window not found." {
return "TargetError";
}
if message.contains("has no property named") {
return "PropertyError";
}
if message.contains("has no method named") {
return "MethodError";
}
if message == "Item has no value." {
return "UnsetItemError";
}
if message.ends_with("has not been assigned a value.") {
return "UnsetError";
}
if message == "Invalid index." {
return "IndexError";
}
if message == "Invalid value." || message.ends_with(" is invalid.") {
return "ValueError";
}
if message == "Invalid base." {
return "ValueError";
}
if message == "Invalid parameter(s)." {
return "ValueError";
}
if message.ends_with(" must not be omitted in this case.") {
return "ValueError";
}
if message == "Invalid option." {
return "ValueError";
}
if message == "This dynamic assignment requires a \"global\" declaration." {
return "Error";
}
if message.starts_with("Expected a ")
|| message.starts_with("Expected an ")
|| message.contains(" requires ")
|| message == "Value not enumerable."
|| message == "Type mismatch."
{
return "TypeError";
}
"Error"
}
pub(crate) fn is_a_class(class: &str) -> bool {
let class = class.to_lowercase();
CLASSES.iter().any(|(name, _, _)| *name == class)
}
const PROPERTIES: [&str; 6] = ["message", "what", "extra", "file", "line", "stack"];
const METHODS: [&str; 10] = [
"__new",
"ownprops",
"hasownprop",
"defineprop",
"deleteprop",
"getownpropdesc",
"hasprop",
"hasmethod",
"getmethod",
"hasbase",
];
pub(crate) fn names() -> Vec<&'static str> {
PROPERTIES.iter().chain(METHODS.iter()).copied().collect()
}
pub(crate) fn construct(
class: &str,
arguments: &[Value],
rt: &mut Runtime,
line: u32,
) -> Result<Value, RuntimeFailure> {
let message = arguments
.first()
.map(|value| value.to_text())
.unwrap_or_else(|| the_spelling_of(class).unwrap_or_default());
let what = arguments
.get(1)
.map(|value| value.to_text())
.unwrap_or_default();
let extra = arguments
.get(2)
.map(|value| value.to_text())
.unwrap_or_default();
Ok(error_value_of(
class,
&message,
&what,
&extra,
line,
rt.script_path().unwrap_or(""),
&rt.the_stack(),
))
}
pub(crate) fn error_value_of(
class: &str,
message: &str,
what: &str,
extra: &str,
line: u32,
file: &str,
stack: &str,
) -> Value {
let mut properties = BTreeMap::new();
put(&mut properties, "Message", Value::Text(message.to_string()));
put(&mut properties, "What", Value::Text(what.to_string()));
put(&mut properties, "Extra", Value::Text(extra.to_string()));
put(&mut properties, "File", Value::Text(file.to_string()));
put(&mut properties, "Line", Value::Int(line as i64));
put(&mut properties, "Stack", Value::Text(stack.to_string()));
Value::Object(SharedCell::new(Object {
class: class.to_lowercase(),
properties,
}))
}
pub(crate) fn call(
method: &str,
_this: &Value,
arguments: &[Value],
rt: &mut Runtime,
line: u32,
) -> Option<Result<Value, RuntimeFailure>> {
match method.to_lowercase().as_str() {
"__new" => Some(construct("error", arguments, rt, line)),
_ => None,
}
}
pub(crate) fn property(
_name: &str,
_this: &Value,
_rt: &mut Runtime,
_line: u32,
) -> Option<Result<Value, RuntimeFailure>> {
None
}
pub(crate) fn set_property(
_name: &str,
_this: &Value,
_value: Value,
_rt: &mut Runtime,
_line: u32,
) -> Option<Result<(), RuntimeFailure>> {
None
}
pub(crate) const KS_CLASSES: [(&str, &str, &str, &str); 2] = [
(
"argumenterror",
"ArgumentError",
"error",
"A required parameter was omitted or unset.",
),
("unsupportederror", "UnsupportedError", "oserror", ""),
];
pub(crate) fn the_message_of_the_extension(class: &str) -> Option<&'static str> {
let class = class.to_lowercase();
KS_CLASSES
.iter()
.find(|(name, _, _, _)| *name == class)
.map(|(_, _, _, message)| *message)
}
pub(crate) fn construct_the_extension(
class: &str,
arguments: &[Value],
rt: &mut Runtime,
line: u32,
) -> Option<Result<Value, RuntimeFailure>> {
let default = the_message_of_the_extension(class)?;
let message = arguments
.first()
.map(|value| value.to_text())
.unwrap_or_else(|| default.to_string());
let what = arguments
.get(1)
.map(|value| value.to_text())
.unwrap_or_default();
let extra = arguments
.get(2)
.map(|value| value.to_text())
.unwrap_or_default();
Some(Ok(error_value_of(
&class.to_lowercase(),
&message,
&what,
&extra,
line,
rt.script_path().unwrap_or(""),
&rt.the_stack(),
)))
}