From 2c89f62646497d7a43e383d2fe6c575b82169e2a Mon Sep 17 00:00:00 2001 From: Daniel Grunwald Date: Sat, 10 Dec 2016 12:41:08 +0100 Subject: [PATCH] Fix non_upper_case_globals warning in py_class!() macro. --- src/py_class/py_class_impl.py | 28 ++++++++++++++-------------- src/py_class/py_class_impl2.rs | 28 ++++++++++++++-------------- src/py_class/py_class_impl3.rs | 28 ++++++++++++++-------------- 3 files changed, 42 insertions(+), 42 deletions(-) diff --git a/src/py_class/py_class_impl.py b/src/py_class/py_class_impl.py index 0f577fa4..0c9ae74b 100644 --- a/src/py_class/py_class_impl.py +++ b/src/py_class/py_class_impl.py @@ -137,16 +137,16 @@ base_case = ''' return Ok($class { _unsafe_inner: obj }); // hide statics in create_instance to avoid name conflicts - static mut type_object : $crate::_detail::ffi::PyTypeObject + static mut TYPE_OBJECT : $crate::_detail::ffi::PyTypeObject = py_class_type_object_static_init!($class, $gc, $slots); - static mut init_active: bool = false; + static mut INIT_ACTIVE: bool = false; - // trait implementations that need direct access to type_object + // trait implementations that need direct access to TYPE_OBJECT impl $crate::PythonObjectWithTypeObject for $class { fn type_object(py: $crate::Python) -> $crate::PyType { unsafe { - if $crate::py_class::is_ready(py, &type_object) { - $crate::PyType::from_type_ptr(py, &mut type_object) + if $crate::py_class::is_ready(py, &TYPE_OBJECT) { + $crate::PyType::from_type_ptr(py, &mut TYPE_OBJECT) } else { // automatically initialize the class on-demand <$class as $crate::py_class::PythonObjectFromPyClassMacro>::initialize(py) @@ -159,26 +159,26 @@ base_case = ''' impl $crate::py_class::PythonObjectFromPyClassMacro for $class { fn initialize(py: $crate::Python) -> $crate::PyResult<$crate::PyType> { unsafe { - if $crate::py_class::is_ready(py, &type_object) { - return Ok($crate::PyType::from_type_ptr(py, &mut type_object)); + if $crate::py_class::is_ready(py, &TYPE_OBJECT) { + return Ok($crate::PyType::from_type_ptr(py, &mut TYPE_OBJECT)); } - assert!(!init_active, + assert!(!INIT_ACTIVE, concat!("Reentrancy detected: already initializing class ", stringify!($class))); - init_active = true; + INIT_ACTIVE = true; let res = init(py); - init_active = false; + INIT_ACTIVE = false; res } } } fn init($py: $crate::Python) -> $crate::PyResult<$crate::PyType> { - py_class_type_object_dynamic_init!($class, $py, type_object, $slots); - py_class_init_members!($class, $py, type_object, $members); + py_class_type_object_dynamic_init!($class, $py, TYPE_OBJECT, $slots); + py_class_init_members!($class, $py, TYPE_OBJECT, $members); unsafe { - if $crate::_detail::ffi::PyType_Ready(&mut type_object) == 0 { - Ok($crate::PyType::from_type_ptr($py, &mut type_object)) + if $crate::_detail::ffi::PyType_Ready(&mut TYPE_OBJECT) == 0 { + Ok($crate::PyType::from_type_ptr($py, &mut TYPE_OBJECT)) } else { Err($crate::PyErr::fetch($py)) } diff --git a/src/py_class/py_class_impl2.rs b/src/py_class/py_class_impl2.rs index b15d5411..704b92d7 100644 --- a/src/py_class/py_class_impl2.rs +++ b/src/py_class/py_class_impl2.rs @@ -129,16 +129,16 @@ macro_rules! py_class_impl { return Ok($class { _unsafe_inner: obj }); // hide statics in create_instance to avoid name conflicts - static mut type_object : $crate::_detail::ffi::PyTypeObject + static mut TYPE_OBJECT : $crate::_detail::ffi::PyTypeObject = py_class_type_object_static_init!($class, $gc, $slots); - static mut init_active: bool = false; + static mut INIT_ACTIVE: bool = false; - // trait implementations that need direct access to type_object + // trait implementations that need direct access to TYPE_OBJECT impl $crate::PythonObjectWithTypeObject for $class { fn type_object(py: $crate::Python) -> $crate::PyType { unsafe { - if $crate::py_class::is_ready(py, &type_object) { - $crate::PyType::from_type_ptr(py, &mut type_object) + if $crate::py_class::is_ready(py, &TYPE_OBJECT) { + $crate::PyType::from_type_ptr(py, &mut TYPE_OBJECT) } else { // automatically initialize the class on-demand <$class as $crate::py_class::PythonObjectFromPyClassMacro>::initialize(py) @@ -151,26 +151,26 @@ macro_rules! py_class_impl { impl $crate::py_class::PythonObjectFromPyClassMacro for $class { fn initialize(py: $crate::Python) -> $crate::PyResult<$crate::PyType> { unsafe { - if $crate::py_class::is_ready(py, &type_object) { - return Ok($crate::PyType::from_type_ptr(py, &mut type_object)); + if $crate::py_class::is_ready(py, &TYPE_OBJECT) { + return Ok($crate::PyType::from_type_ptr(py, &mut TYPE_OBJECT)); } - assert!(!init_active, + assert!(!INIT_ACTIVE, concat!("Reentrancy detected: already initializing class ", stringify!($class))); - init_active = true; + INIT_ACTIVE = true; let res = init(py); - init_active = false; + INIT_ACTIVE = false; res } } } fn init($py: $crate::Python) -> $crate::PyResult<$crate::PyType> { - py_class_type_object_dynamic_init!($class, $py, type_object, $slots); - py_class_init_members!($class, $py, type_object, $members); + py_class_type_object_dynamic_init!($class, $py, TYPE_OBJECT, $slots); + py_class_init_members!($class, $py, TYPE_OBJECT, $members); unsafe { - if $crate::_detail::ffi::PyType_Ready(&mut type_object) == 0 { - Ok($crate::PyType::from_type_ptr($py, &mut type_object)) + if $crate::_detail::ffi::PyType_Ready(&mut TYPE_OBJECT) == 0 { + Ok($crate::PyType::from_type_ptr($py, &mut TYPE_OBJECT)) } else { Err($crate::PyErr::fetch($py)) } diff --git a/src/py_class/py_class_impl3.rs b/src/py_class/py_class_impl3.rs index 3f6eed27..697c199b 100644 --- a/src/py_class/py_class_impl3.rs +++ b/src/py_class/py_class_impl3.rs @@ -129,16 +129,16 @@ macro_rules! py_class_impl { return Ok($class { _unsafe_inner: obj }); // hide statics in create_instance to avoid name conflicts - static mut type_object : $crate::_detail::ffi::PyTypeObject + static mut TYPE_OBJECT : $crate::_detail::ffi::PyTypeObject = py_class_type_object_static_init!($class, $gc, $slots); - static mut init_active: bool = false; + static mut INIT_ACTIVE: bool = false; - // trait implementations that need direct access to type_object + // trait implementations that need direct access to TYPE_OBJECT impl $crate::PythonObjectWithTypeObject for $class { fn type_object(py: $crate::Python) -> $crate::PyType { unsafe { - if $crate::py_class::is_ready(py, &type_object) { - $crate::PyType::from_type_ptr(py, &mut type_object) + if $crate::py_class::is_ready(py, &TYPE_OBJECT) { + $crate::PyType::from_type_ptr(py, &mut TYPE_OBJECT) } else { // automatically initialize the class on-demand <$class as $crate::py_class::PythonObjectFromPyClassMacro>::initialize(py) @@ -151,26 +151,26 @@ macro_rules! py_class_impl { impl $crate::py_class::PythonObjectFromPyClassMacro for $class { fn initialize(py: $crate::Python) -> $crate::PyResult<$crate::PyType> { unsafe { - if $crate::py_class::is_ready(py, &type_object) { - return Ok($crate::PyType::from_type_ptr(py, &mut type_object)); + if $crate::py_class::is_ready(py, &TYPE_OBJECT) { + return Ok($crate::PyType::from_type_ptr(py, &mut TYPE_OBJECT)); } - assert!(!init_active, + assert!(!INIT_ACTIVE, concat!("Reentrancy detected: already initializing class ", stringify!($class))); - init_active = true; + INIT_ACTIVE = true; let res = init(py); - init_active = false; + INIT_ACTIVE = false; res } } } fn init($py: $crate::Python) -> $crate::PyResult<$crate::PyType> { - py_class_type_object_dynamic_init!($class, $py, type_object, $slots); - py_class_init_members!($class, $py, type_object, $members); + py_class_type_object_dynamic_init!($class, $py, TYPE_OBJECT, $slots); + py_class_init_members!($class, $py, TYPE_OBJECT, $members); unsafe { - if $crate::_detail::ffi::PyType_Ready(&mut type_object) == 0 { - Ok($crate::PyType::from_type_ptr($py, &mut type_object)) + if $crate::_detail::ffi::PyType_Ready(&mut TYPE_OBJECT) == 0 { + Ok($crate::PyType::from_type_ptr($py, &mut TYPE_OBJECT)) } else { Err($crate::PyErr::fetch($py)) }