test

youknowone · youknowone · commit 0cb1cf9b51d2 · 2022-06-02T06:46:39.000+09:00
diff --git a/stdlib/src/binascii.rs b/stdlib/src/binascii.rs
@@ -6,6 +6,7 @@ pub(super) use decl::crc32;
 mod decl {
     use crate::vm::{
         builtins::{PyIntRef, PyTypeRef},
+        exceptions::SimpleException,
         function::{ArgAsciiBuffer, ArgBytesLike, OptionalArg},
         PyResult, VirtualMachine,
     };
@@ -57,18 +58,24 @@ mod decl {
 
     #[pyfunction(name = "a2b_hex")]
     #[pyfunction]
-    fn unhexlify(data: ArgAsciiBuffer, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+    fn unhexlify(data: ArgAsciiBuffer, vm: &VirtualMachine) -> Result<Vec<u8>, SimpleException> {
         data.with_ref(|hex_bytes| {
             if hex_bytes.len() % 2 != 0 {
-                return Err(vm.new_value_error("Odd-length string".to_owned()));
+                return Err(SimpleException::with_message(
+                    vm.ctx.exceptions.value_error,
+                    "Odd-length string",
+                ));
             }
 
             let mut unhex = Vec::<u8>::with_capacity(hex_bytes.len() / 2);
             for (n1, n2) in hex_bytes.iter().tuples() {
                 if let (Some(n1), Some(n2)) = (unhex_nibble(*n1), unhex_nibble(*n2)) {
                     unhex.push(n1 << 4 | n2);
                 } else {
-                    return Err(vm.new_value_error("Non-hexadecimal digit found".to_owned()));
+                    return Err(SimpleException::with_message(
+                        vm.ctx.exceptions.value_error,
+                        "Non-hexadecimal digit found",
+                    ));
                 }
             }
 
diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs
@@ -280,6 +280,52 @@ impl TryFromObject for ExceptionCtor {
     }
 }
 
+pub struct SimpleException {
+    typ: &'static Py<PyType>,
+    message: Option<&'static str>,
+}
+
+impl SimpleException {
+    #[inline]
+    pub fn new(typ: &'static Py<PyType>) -> Self {
+        Self { typ, message: None }
+    }
+    #[inline]
+    pub fn with_message(typ: &'static Py<PyType>, message: &'static str) -> Self {
+        let message = Some(message);
+        Self { typ, message }
+    }
+}
+
+impl ToPyException for SimpleException {
+    #[inline]
+    fn to_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        let Self { typ, message } = self;
+        match message {
+            Some(message) => vm.new_exception_msg(typ.to_owned(), message.to_owned()),
+            None => vm.new_exception_empty(typ.to_owned()),
+        }
+    }
+}
+
+pub struct DeferredMessageException<'vm, M>
+where
+    M: FnOnce(&VirtualMachine) -> String,
+{
+    typ: &'vm PyTypeRef,
+    build_message: M,
+}
+
+impl<'vm, M> ToPyException for DeferredMessageException<'vm, M>
+where
+    M: FnOnce(&VirtualMachine) -> String,
+{
+    fn to_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        let Self { typ, build_message } = self;
+        vm.new_exception_msg(typ.clone(), build_message(vm))
+    }
+}
+
 impl ExceptionCtor {
     pub fn instantiate(self, vm: &VirtualMachine) -> PyResult<PyBaseExceptionRef> {
         match self {
