got enums to work

programmerjake · programmerjake · commit 4f1281aa7394 · 2019-11-11T02:06:42.000-08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -15,7 +15,7 @@ crate-type = ["rlib", "cdylib"]
 
 [features]
 default = []
-python = ["pyo3"]
+python = ["pyo3", "once_cell"]
 python-extension = ["python", "pyo3/extension-module"]
 
 [dependencies]
@@ -28,6 +28,10 @@ bitflags = "1.2"
 [dependencies.algebraics]
 version = ">= 0.1.2, < 0.2"
 
+[dependencies.once_cell]
+version = "1.2"
+optional = true
+
 [dependencies.pyo3]
 version = "0.8.2"
 optional = true
diff --git a/src/lib.rs b/src/lib.rs
@@ -33,15 +33,18 @@ use std::ops::ShrAssign;
 use pyo3::prelude::*;
 
 mod python;
+#[macro_use]
+mod python_macros;
 
 #[cfg(test)]
 mod test_cases;
 
-#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
-#[repr(u8)]
-pub enum Sign {
-    Positive = 0,
-    Negative = 1,
+python_enum! {
+    #[pyenum(module = simple_soft_float, repr = u8, test_fn = test_sign_enum)]
+    pub enum Sign {
+        Positive = 0,
+        Negative = 1,
+    }
 }
 
 impl Neg for Sign {
@@ -123,14 +126,15 @@ impl_float_bits_type!(u32, to_u32);
 impl_float_bits_type!(u64, to_u64);
 impl_float_bits_type!(u128, to_u128);
 
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-#[repr(u32)]
-pub enum RoundingMode {
-    TiesToEven = 0,
-    TowardZero = 1,
-    TowardNegative = 2,
-    TowardPositive = 3,
-    TiesToAway = 4,
+python_enum! {
+    #[pyenum(module = simple_soft_float, repr = u8, test_fn = test_rounding_mode_enum)]
+    pub enum RoundingMode {
+        TiesToEven = 0,
+        TowardZero = 1,
+        TowardNegative = 2,
+        TowardPositive = 3,
+        TiesToAway = 4,
+    }
 }
 
 impl Default for RoundingMode {
@@ -179,19 +183,23 @@ impl Default for TininessDetectionMode {
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-pub enum BinaryNaNPropagationMode {
-    AlwaysCanonical,
-    FirstSecond,
-    SecondFirst,
-    FirstSecondPreferringSNaN,
-    SecondFirstPreferringSNaN,
+python_enum! {
+    #[pyenum(module = simple_soft_float, repr = u8, test_fn = test_binary_nan_propagation_mode_enum)]
+    pub enum BinaryNaNPropagationMode {
+        AlwaysCanonical,
+        FirstSecond,
+        SecondFirst,
+        FirstSecondPreferringSNaN,
+        SecondFirstPreferringSNaN,
+    }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-pub enum UnaryNaNPropagationMode {
-    AlwaysCanonical,
-    First,
+python_enum! {
+    #[pyenum(module = simple_soft_float, repr = u8, test_fn = test_unary_nan_propagation_mode_enum)]
+    pub enum UnaryNaNPropagationMode {
+        AlwaysCanonical,
+        First,
+    }
 }
 
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
@@ -340,21 +348,23 @@ impl Default for TernaryNaNPropagationResults {
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-pub enum TernaryNaNPropagationMode {
-    AlwaysCanonical,
-    FirstSecondThird,
-    FirstThirdSecond,
-    SecondFirstThird,
-    SecondThirdFirst,
-    ThirdFirstSecond,
-    ThirdSecondFirst,
-    FirstSecondThirdPreferringSNaN,
-    FirstThirdSecondPreferringSNaN,
-    SecondFirstThirdPreferringSNaN,
-    SecondThirdFirstPreferringSNaN,
-    ThirdFirstSecondPreferringSNaN,
-    ThirdSecondFirstPreferringSNaN,
+python_enum! {
+    #[pyenum(module = simple_soft_float, repr = u8, test_fn = test_ternary_nan_propagation_mode_enum)]
+    pub enum TernaryNaNPropagationMode {
+        AlwaysCanonical,
+        FirstSecondThird,
+        FirstThirdSecond,
+        SecondFirstThird,
+        SecondThirdFirst,
+        ThirdFirstSecond,
+        ThirdSecondFirst,
+        FirstSecondThirdPreferringSNaN,
+        FirstThirdSecondPreferringSNaN,
+        SecondFirstThirdPreferringSNaN,
+        SecondThirdFirstPreferringSNaN,
+        ThirdFirstSecondPreferringSNaN,
+        ThirdSecondFirstPreferringSNaN,
+    }
 }
 
 impl Default for TernaryNaNPropagationMode {
@@ -547,11 +557,13 @@ impl TernaryNaNPropagationMode {
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-pub enum FMAInfZeroQNaNResult {
-    FollowNaNPropagationMode,
-    CanonicalAndGenerateInvalid,
-    PropagateAndGenerateInvalid,
+python_enum! {
+    #[pyenum(module = simple_soft_float, repr = u8, test_fn = test_fma_inf_zero_qnan_result_enum)]
+    pub enum FMAInfZeroQNaNResult {
+        FollowNaNPropagationMode,
+        CanonicalAndGenerateInvalid,
+        PropagateAndGenerateInvalid,
+    }
 }
 
 impl Default for FMAInfZeroQNaNResult {
@@ -560,10 +572,12 @@ impl Default for FMAInfZeroQNaNResult {
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-pub enum FloatToFloatConversionNaNPropagationMode {
-    AlwaysCanonical,
-    RetainMostSignificantBits,
+python_enum! {
+    #[pyenum(module = simple_soft_float, repr = u8, test_fn = test_float_to_float_conversion_nan_propagation_mode_enum)]
+    pub enum FloatToFloatConversionNaNPropagationMode {
+        AlwaysCanonical,
+        RetainMostSignificantBits,
+    }
 }
 
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Default)]
@@ -746,6 +760,7 @@ impl Default for QuietNaNFormat {
     }
 }
 
+#[cfg_attr(feature = "python", pyclass(module = "simple_soft_float"))]
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct PlatformProperties {
     pub canonical_nan_sign: Sign,
@@ -818,6 +833,15 @@ macro_rules! platform_properties_constants {
             pub const $ident:ident: PlatformProperties = $init:expr;
         )+
     ) => {
+        #[cfg(feature = "python")]
+        impl PlatformProperties {
+            fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
+                m.add_class::<Self>()?;
+                $(m.add::<PyObject>(concat!("PlatformProperties_", stringify!($ident)), Self::$ident.into_py(py))?;)+
+                Ok(())
+            }
+        }
+
         impl PlatformProperties {
             $(
                 $(#[$meta])*
diff --git a/src/python.rs b/src/python.rs
@@ -2,9 +2,18 @@
 // See Notices.txt for copyright information
 #![cfg(feature = "python")]
 
+use crate::python_macros::PythonEnum;
+use crate::BinaryNaNPropagationMode;
 use crate::DynamicFloat;
+use crate::FMAInfZeroQNaNResult;
 use crate::FloatProperties;
+use crate::FloatToFloatConversionNaNPropagationMode;
+use crate::PlatformProperties;
+use crate::RoundingMode;
+use crate::Sign;
 use crate::StatusFlags;
+use crate::TernaryNaNPropagationMode;
+use crate::UnaryNaNPropagationMode;
 use pyo3::basic::CompareOp;
 use pyo3::exceptions::TypeError;
 use pyo3::prelude::*;
@@ -14,8 +23,23 @@ use pyo3::types::PyType;
 use pyo3::wrap_pymodule;
 use pyo3::PyNativeType;
 use pyo3::PyObjectProtocol;
+use std::borrow::Cow;
 use std::fmt::Write as _;
 
+pub(crate) trait ToPythonRepr {
+    fn to_python_repr(&self) -> Cow<str>;
+}
+
+impl ToPythonRepr for bool {
+    fn to_python_repr(&self) -> Cow<str> {
+        if *self {
+            Cow::Borrowed("True")
+        } else {
+            Cow::Borrowed("False")
+        }
+    }
+}
+
 impl FromPyObject<'_> for StatusFlags {
     fn extract(object: &PyAny) -> PyResult<Self> {
         if !Self::get_python_class(object.py())
@@ -58,7 +82,7 @@ impl StatusFlags {
 
 #[cfg(feature = "python")]
 #[pymodule]
-fn simple_soft_float(py: Python, m: &PyModule) -> PyResult<()> {
+pub(crate) fn simple_soft_float(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_class::<DynamicFloat>()?;
     let dict = PyDict::new(py);
     fn make_src() -> Result<String, std::fmt::Error> {
@@ -77,6 +101,14 @@ fn simple_soft_float(py: Python, m: &PyModule) -> PyResult<()> {
         .into_py(py);
     m.add(StatusFlags::NAME, class)?;
     m.add_class::<FloatProperties>()?;
+    BinaryNaNPropagationMode::add_to_module(py, m)?;
+    FloatToFloatConversionNaNPropagationMode::add_to_module(py, m)?;
+    FMAInfZeroQNaNResult::add_to_module(py, m)?;
+    RoundingMode::add_to_module(py, m)?;
+    Sign::add_to_module(py, m)?;
+    TernaryNaNPropagationMode::add_to_module(py, m)?;
+    UnaryNaNPropagationMode::add_to_module(py, m)?;
+    PlatformProperties::add_to_module(py, m)?;
     Ok(())
 }
 
@@ -98,28 +130,115 @@ impl DynamicFloat {
     // FIXME: finish
 }
 
+macro_rules! impl_platform_properties_new {
+    ($($name:ident:$type:ty,)+) => {
+        #[pymethods]
+        impl PlatformProperties {
+            #[new]
+            #[args(
+                value = "None",
+                "*",
+                $($name = "None"),+
+            )]
+            fn __new__(
+                obj: &PyRawObject,
+                value: Option<&Self>,
+                $($name: Option<$type>,)+
+            ) {
+                let mut value = value.copied().unwrap_or_default();
+                $(value.$name = $name.unwrap_or(value.$name);)+
+                obj.init(value);
+            }
+        }
+
+        #[pyproto]
+        impl PyObjectProtocol for PlatformProperties {
+            fn __repr__(&self) -> PyResult<String> {
+                #![allow(unused_assignments)]
+                let mut retval = String::new();
+                write!(retval, "PlatformProperties(").unwrap();
+                let mut first = true;
+                $(
+                    if first {
+                        first = false;
+                    } else {
+                        write!(retval, ", ").unwrap();
+                    }
+                    write!(retval, concat!(stringify!($name), "={}"), self.$name.to_python_repr()).unwrap();
+                )+
+                write!(retval, ")").unwrap();
+                Ok(retval)
+            }
+            fn __richcmp__(&self, other: &PyAny, op: CompareOp) -> PyResult<PyObject> {
+                if let Ok(rhs) = <&Self>::extract(other) {
+                    match op {
+                        CompareOp::Eq => return Ok((self == rhs).into_py(other.py())),
+                        CompareOp::Ne => return Ok((self != rhs).into_py(other.py())),
+                        CompareOp::Ge | CompareOp::Gt | CompareOp::Le | CompareOp::Lt => {}
+                    };
+                }
+                Ok(other.py().NotImplemented())
+            }
+        }
+    };
+}
+
+impl_platform_properties_new!(
+    canonical_nan_sign: Sign,
+    canonical_nan_mantissa_msb: bool,
+    canonical_nan_mantissa_second_to_msb: bool,
+    canonical_nan_mantissa_rest: bool,
+    std_bin_ops_nan_propagation_mode: BinaryNaNPropagationMode,
+    fma_nan_propagation_mode: TernaryNaNPropagationMode,
+    fma_inf_zero_qnan_result: FMAInfZeroQNaNResult,
+    round_to_integral_nan_propagation_mode: UnaryNaNPropagationMode,
+    next_up_or_down_nan_propagation_mode: UnaryNaNPropagationMode,
+    scale_b_nan_propagation_mode: UnaryNaNPropagationMode,
+    sqrt_nan_propagation_mode: UnaryNaNPropagationMode,
+    float_to_float_conversion_nan_propagation_mode: FloatToFloatConversionNaNPropagationMode,
+    rsqrt_nan_propagation_mode: UnaryNaNPropagationMode,
+);
+
 #[pymethods]
-impl FloatProperties {
+impl PlatformProperties {
     // FIXME: finish
 }
 
+#[pymethods]
+impl FloatProperties {
+    #[new]
+    fn __new__(
+        obj: &PyRawObject,
+        exponent_width: usize,
+        mantissa_width: usize,
+        has_implicit_leading_bit: bool,
+        has_sign_bit: bool,
+        platform_properties: &PlatformProperties,
+    ) {
+        obj.init(Self::new_with_extended_flags(
+            exponent_width,
+            mantissa_width,
+            has_implicit_leading_bit,
+            has_sign_bit,
+            *platform_properties,
+        ));
+    }
+}
+
 #[pyproto]
 impl PyObjectProtocol for FloatProperties {
     fn __repr__(&self) -> PyResult<String> {
         Ok(format!("<{:?}>", self))
     }
     fn __richcmp__(&self, other: &PyAny, op: CompareOp) -> PyResult<PyObject> {
-        let inverted = match op {
-            CompareOp::Eq => false,
-            CompareOp::Ne => true,
-            CompareOp::Ge | CompareOp::Gt | CompareOp::Le | CompareOp::Lt => {
-                return Ok(other.py().NotImplemented());
-            }
-        };
-        match <&FloatProperties>::extract(other) {
-            Ok(v) => Ok(if inverted { self != v } else { self == v }.into_py(other.py())),
-            Err(_) => Ok(other.py().NotImplemented()),
+        if let Ok(rhs) = <&FloatProperties>::extract(other) {
+            match op {
+                CompareOp::Eq => return Ok((self == rhs).into_py(other.py())),
+                CompareOp::Ne => return Ok((self != rhs).into_py(other.py())),
+                CompareOp::Ge | CompareOp::Gt | CompareOp::Le | CompareOp::Lt => {}
+            };
         }
+        Ok(other.py().NotImplemented())
     }
 }
 
diff --git a/src/python_macros.rs b/src/python_macros.rs
