From f4fac221fa55fb6af8eee5496a4cecbb6ea49634 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Mon, 22 Sep 2003 22:55:17 +0000 Subject: [PATCH] - Compliance with ISO/IEC 14882:1998(E) 17.4.3.1.2 -> eg double underscores removed - Potential member variable and method name clashes remove by preceding with 'swig' - consistent use of C++ booleans for the swig_disown flag across and within the modules that use this it in director code. git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@5139 626c5289-ae23-0410-ae9c-e8d60b6d4f22 --- Lib/java/director.swg | 48 ++++++++--------- Lib/ocaml/director.swg | 92 ++++++++++++++++----------------- Lib/python/director.swg | 111 ++++++++++++++++++++-------------------- Lib/python/python.swg | 2 +- Lib/ruby/director.swg | 93 +++++++++++++++++---------------- 5 files changed, 170 insertions(+), 176 deletions(-) diff --git a/Lib/java/director.swg b/Lib/java/director.swg index 4273c3dd4..78beecbd4 100644 --- a/Lib/java/director.swg +++ b/Lib/java/director.swg @@ -16,50 +16,46 @@ namespace Swig { /* director base class */ class Director { private: - /* pointer to java virtual machine */ - JavaVM *__jvm; + /* pointer to Java virtual machine */ + JavaVM *swig_jvm; protected: - /* pointer to the wrapped java object */ - jobject __self; + /* pointer to the wrapped Java object */ + jobject swig_self; + /* Acquire Java VM environment from Java VM */ - JNIEnv *__acquire_jenv() const { - JNIEnv *env; - __jvm->AttachCurrentThread((void **) &env, NULL); + JNIEnv *swig_acquire_jenv() const { + JNIEnv *env = NULL; + swig_jvm->AttachCurrentThread((void **) &env, NULL); return env; } public: - Director(JNIEnv *jenv): - __jvm((JavaVM *) NULL), - __self(NULL) { + Director(JNIEnv *jenv) : swig_jvm((JavaVM *) NULL), swig_self(NULL) { /* Acquire the Java VM pointer */ - jenv->GetJavaVM(&__jvm); + jenv->GetJavaVM(&swig_jvm); } /* Remove the Java object global lock at destruction */ virtual ~Director() { - if (__self) { - JNIEnv *jenv; - jmethodID disconn_meth; - - jenv = __acquire_jenv(); - disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(__self), "__director_disconnect", "()V"); + if (swig_self) { + JNIEnv *jenv = swig_acquire_jenv(); + jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(swig_self), "swig_director_disconnect", "()V"); if (disconn_meth) - jenv->CallVoidMethod(__self, disconn_meth); - jenv->DeleteGlobalRef(__self); - __self = (jobject) NULL; + jenv->CallVoidMethod(swig_self, disconn_meth); + jenv->DeleteGlobalRef(swig_self); + swig_self = (jobject) NULL; } } - /* Set __self and get Java global reference on object */ - inline void __set_self(JNIEnv *jenv, jobject jself) { - __self = jenv->NewGlobalRef(jself); + /* Set swig_self and get Java global reference on object */ + void swig_set_self(JNIEnv *jenv, jobject jself) { + swig_self = jenv->NewGlobalRef(jself); } - /* return a pointer to the wrapped java object */ - inline jobject __get_self() const { - return __self; + /* return a pointer to the wrapped Java object */ + jobject swig_get_self() const { + return swig_self; } }; } diff --git a/Lib/ocaml/director.swg b/Lib/ocaml/director.swg index 4ca2e9f02..605541f45 100644 --- a/Lib/ocaml/director.swg +++ b/Lib/ocaml/director.swg @@ -34,105 +34,105 @@ namespace Swig { class Director { private: /* pointer to the wrapped ocaml object */ - CAML_VALUE _self; + CAML_VALUE swig_self; /* flag indicating whether the object is owned by ocaml or c++ */ - mutable int _disown; + mutable bool swig_disown_flag; /* shared flag for breaking recursive director calls */ - static int _up; + static bool swig_up; #ifdef __PTHREAD__ - /* locks for sharing the _up flag in a threaded environment */ - static pthread_mutex_t _mutex_up; - static int _mutex_active; - static pthread_t _mutex_thread; + /* locks for sharing the swig_up flag in a threaded environment */ + static pthread_mutex_t swig_mutex_up; + static bool swig_mutex_active; + static pthread_t swig_mutex_thread; #endif - /* reset the _up flag once the routing direction has been determined */ + /* reset the swig_up flag once the routing direction has been determined */ #ifdef __PTHREAD__ - void __clear_up() const { - Swig::Director::_up = 0; - Swig::Director::_mutex_active = 0; - pthread_mutex_unlock(&_mutex_up); + void swig_clear_up() const { + Swig::Director::swig_up = false; + Swig::Director::swig_mutex_active = false; + pthread_mutex_unlock(&swig_mutex_up); } #else - void __clear_up() const { - Swig::Director::_up = 0; + void swig_clear_up() const { + Swig::Director::swig_up = false; } #endif public: /* wrap a ocaml object, optionally taking ownership */ - Director(CAML_VALUE self, int disown): _self(self), _disown(disown) { - register_global_root(&_self); + Director(CAML_VALUE self, bool disown) : swig_self(self), swig_disown_flag(disown) { + register_global_root(&swig_self); } /* discard our reference at destruction */ virtual ~Director() { - remove_global_root(&_self); - __disown(); + remove_global_root(&swig_self); + swig_disown(); // Disown is safe here because we're just divorcing a reference that // points to us. } /* return a pointer to the wrapped ocaml object */ - CAML_VALUE __get_self() const { - return callback(*caml_named_value("caml_director_get_self"),_self); + CAML_VALUE swig_get_self() const { + return callback(*caml_named_value("caml_director_get_self"),swig_self); } - /* get the _up flag to determine if the method call should be routed + /* get the swig_up flag to determine if the method call should be routed * to the c++ base class or through the wrapped ocaml object */ #ifdef __PTHREAD__ - int __get_up() const { - if (Swig::Director::_mutex_active) { - if (pthread_equal(Swig::Director::_mutex_thread, pthread_self())) { - int up = _up; - __clear_up(); + bool swig_get_up() const { + if (Swig::Director::swig_mutex_active) { + if (pthread_equal(Swig::Director::swig_mutex_thread, pthread_self())) { + bool up = swig_up; + swig_clear_up(); return up; } } - return 0; + return false; } #else - int __get_up() const { - int up = _up; - _up = 0; + bool swig_get_up() const { + bool up = swig_up; + swig_up = false; return up; } #endif - /* set the _up flag if the next method call should be directed to + /* set the swig_up flag if the next method call should be directed to * the c++ base class rather than the wrapped ocaml object */ #ifdef __PTHREAD__ - void __set_up() const { - pthread_mutex_lock(&Swig::Director::_mutex_up); - Swig::Director::_mutex_thread = pthread_self(); - Swig::Director::_mutex_active = 1; - Swig::Director::_up = 1; + void swig_set_up() const { + pthread_mutex_lock(&Swig::Director::swig_mutex_up); + Swig::Director::swig_mutex_thread = pthread_self(); + Swig::Director::swig_mutex_active = true; + Swig::Director::swig_up = true; } #else - void __set_up() const { - Swig::Director::_up = 1; + void swig_set_up() const { + Swig::Director::swig_up = true; } #endif /* acquire ownership of the wrapped ocaml object (the sense of "disown" * is from ocaml) */ - void __disown() const { - if (!_disown) { - _disown=1; - callback(*caml_named_value("caml_obj_disown"),_self); + void swig_disown() const { + if (!swig_disown_flag) { + swig_disown_flag=true; + callback(*caml_named_value("caml_obj_disown"),swig_self); } } }; - int Swig::Director::_up = 0; + bool Swig::Director::swig_up = false; #ifdef __PTHREAD__ - MUTEX_INIT(Swig::Director::_mutex_up); - pthread_t Swig::Director::_mutex_thread; - int Swig::Director::_mutex_active = 0; + MUTEX_INIT(Swig::Director::swig_mutex_up); + pthread_t Swig::Director::swig_mutex_thread; + bool Swig::Director::swig_mutex_active = false; #endif } diff --git a/Lib/python/director.swg b/Lib/python/director.swg index 66befc891..f13073a27 100644 --- a/Lib/python/director.swg +++ b/Lib/python/director.swg @@ -15,12 +15,12 @@ namespace Swig { /* base class for director exceptions */ class DirectorException { protected: - std::string _msg; + std::string swig_msg; public: DirectorException(const char* msg="") { } - const char *getMessage() { - return _msg.c_str(); + const char *getMessage() const { + return swig_msg.c_str(); } virtual ~DirectorException() {} }; @@ -29,8 +29,8 @@ namespace Swig { class DirectorTypeMismatchException : public Swig::DirectorException { public: DirectorTypeMismatchException(const char* msg="") { - _msg = "Swig director type mismatch: "; - _msg += msg; + swig_msg = "Swig director type mismatch: "; + swig_msg += msg; PyErr_SetString(PyExc_TypeError, msg); } }; @@ -61,118 +61,117 @@ namespace Swig { class Director { private: /* pointer to the wrapped python object */ - PyObject* _self; + PyObject* swig_self; /* flag indicating whether the object is owned by python or c++ */ - mutable int _disown; + mutable bool swig_disown_flag; /* shared flag for breaking recursive director calls */ - static int _up; + static bool swig_up; #ifdef __PTHREAD__ - /* locks for sharing the _up flag in a threaded environment */ - static pthread_mutex_t _mutex_up; - static int _mutex_active; - static pthread_t _mutex_thread; + /* locks for sharing the swig_up flag in a threaded environment */ + static pthread_mutex_t swig_mutex_up; + static bool swig_mutex_active; + static pthread_t swig_mutex_thread; #endif /* decrement the reference count of the wrapped python object */ - void __decref() const { - if (_disown) { - Py_DECREF(_self); + void swig_decref() const { + if (swig_disown_flag) { + Py_DECREF(swig_self); } } - /* reset the _up flag once the routing direction has been determined */ + /* reset the swig_up flag once the routing direction has been determined */ #ifdef __PTHREAD__ - void __clear_up() const { - Swig::Director::_up = 0; - Swig::Director::_mutex_active = 0; - pthread_mutex_unlock(&_mutex_up); + void swig_clear_up() const { + Swig::Director::swig_up = false; + Swig::Director::swig_mutex_active = false; + pthread_mutex_unlock(&swig_mutex_up); } #else - void __clear_up() const { - Swig::Director::_up = 0; + void swig_clear_up() const { + Swig::Director::swig_up = false; } #endif public: /* wrap a python object, optionally taking ownership */ - Director(PyObject* self, int disown): _self(self), _disown(disown) { - __incref(); + Director(PyObject* self, bool disown) : swig_self(self), swig_disown_flag(disown) { + swig_incref(); } /* discard our reference at destruction */ virtual ~Director() { - __decref(); + swig_decref(); } /* return a pointer to the wrapped python object */ - PyObject *__get_self() const { - return _self; + PyObject *swig_get_self() const { + return swig_self; } - - /* get the _up flag to determine if the method call should be routed + /* get the swig_up flag to determine if the method call should be routed * to the c++ base class or through the wrapped python object */ #ifdef __PTHREAD__ - int __get_up() const { - if (Swig::Director::_mutex_active) { - if (pthread_equal(Swig::Director::_mutex_thread, pthread_self())) { - int up = _up; - __clear_up(); + bool swig_get_up() const { + if (Swig::Director::swig_mutex_active) { + if (pthread_equal(Swig::Director::swig_mutex_thread, pthread_self())) { + bool up = swig_up; + swig_clear_up(); return up; } } return 0; } #else - int __get_up() const { - int up = _up; - _up = 0; + bool swig_get_up() const { + bool up = swig_up; + swig_up = false; return up; } #endif - /* set the _up flag if the next method call should be directed to + /* set the swig_up flag if the next method call should be directed to * the c++ base class rather than the wrapped python object */ #ifdef __PTHREAD__ - void __set_up() const { - pthread_mutex_lock(&Swig::Director::_mutex_up); - Swig::Director::_mutex_thread = pthread_self(); - Swig::Director::_mutex_active = 1; - Swig::Director::_up = 1; + void swig_set_up() const { + pthread_mutex_lock(&Swig::Director::swig_mutex_up); + Swig::Director::swig_mutex_thread = pthread_self(); + Swig::Director::swig_mutex_active = true; + Swig::Director::swig_up = true; } #else - void __set_up() const { - Swig::Director::_up = 1; + void swig_set_up() const { + Swig::Director::swig_up = true; } #endif /* acquire ownership of the wrapped python object (the sense of "disown" * is from python) */ - void __disown() const { - if (!_disown) { - _disown=1; - __incref(); + void swig_disown() const { + if (!swig_disown_flag) { + swig_disown_flag=true; + swig_incref(); } } /* increase the reference count of the wrapped python object */ - void __incref() const { - if (_disown) { - Py_INCREF(_self); + void swig_incref() const { + if (swig_disown_flag) { + Py_INCREF(swig_self); } } }; - int Swig::Director::_up = 0; + bool Swig::Director::swig_up = false; #ifdef __PTHREAD__ - MUTEX_INIT(Swig::Director::_mutex_up); - pthread_t Swig::Director::_mutex_thread; - int Swig::Director::_mutex_active = 0; + MUTEX_INIT(Swig::Director::swig_mutex_up); + pthread_t Swig::Director::swig_mutex_thread; + bool Swig::Director::swig_mutex_active = false; #endif } diff --git a/Lib/python/python.swg b/Lib/python/python.swg index 82430f0aa..3f21c110f 100644 --- a/Lib/python/python.swg +++ b/Lib/python/python.swg @@ -471,7 +471,7 @@ if (!proxy) { $input = SWIG_NewPointerObj((void *) $1_name, $1_descriptor, 0); } else { - $input = proxy->__get_self(); + $input = proxy->swig_get_self(); } } } diff --git a/Lib/ruby/director.swg b/Lib/ruby/director.swg index ea33ce57c..11482bdd5 100644 --- a/Lib/ruby/director.swg +++ b/Lib/ruby/director.swg @@ -24,15 +24,15 @@ namespace Swig { /* Base class for director exceptions */ class DirectorException { protected: - VALUE _error; + VALUE swig_error; protected: - DirectorException(VALUE error=Qnil) : _error(error) {} + DirectorException(VALUE error=Qnil) : swig_error(error) {} public: VALUE getType() const { - return CLASS_OF(_error); + return CLASS_OF(swig_error); } VALUE getError() const { - return _error; + return swig_error; } virtual ~DirectorException() {} }; @@ -43,7 +43,7 @@ namespace Swig { DirectorTypeMismatchException(const char *msg="") { VALUE str = rb_str_new2("Swig director type mismatch: "); rb_str_concat(str, rb_str_new2(msg)); - _error = rb_exc_new3(rb_eTypeError, str); + swig_error = rb_exc_new3(rb_eTypeError, str); } }; @@ -75,35 +75,35 @@ namespace Swig { class Director { private: /* pointer to the wrapped Ruby object */ - VALUE _self; + VALUE swig_self; /* flag indicating whether the object is owned by Ruby or c++ */ - mutable bool _disown; + mutable bool swig_disown_flag; /* shared flag for breaking recursive director calls */ - static bool _up; + static bool swig_up; #ifdef __PTHREAD__ - /* locks for sharing the _up flag in a threaded environment */ - static pthread_mutex_t _mutex_up; - static bool _mutex_active; - static pthread_t _mutex_thread; + /* locks for sharing the swig_up flag in a threaded environment */ + static pthread_mutex_t swig_mutex_up; + static bool swig_mutex_active; + static pthread_t swig_mutex_thread; #endif - /* reset the _up flag once the routing direction has been determined */ + /* reset the swig_up flag once the routing direction has been determined */ #ifdef __PTHREAD__ - void __clear_up() const { - Swig::Director::_up = false; - Swig::Director::_mutex_active = false; - pthread_mutex_unlock(&_mutex_up); + void swig_clear_up() const { + Swig::Director::swig_up = false; + Swig::Director::swig_mutex_active = false; + pthread_mutex_unlock(&swig_mutex_up); } #else - void __clear_up() const { - Swig::Director::_up = false; + void swig_clear_up() const { + Swig::Director::swig_up = false; } #endif public: /* wrap a Ruby object, optionally taking ownership */ - Director(VALUE self, bool disown) : _self(self), _disown(disown) { + Director(VALUE self, bool disown) : swig_self(self), swig_disown_flag(disown) { } /* discard our reference at destruction */ @@ -111,64 +111,63 @@ namespace Swig { } /* return a pointer to the wrapped Ruby object */ - VALUE __get_self() const { - return _self; + VALUE swig_get_self() const { + return swig_self; } - - /* get the _up flag to determine if the method call should be routed + /* get the swig_up flag to determine if the method call should be routed * to the c++ base class or through the wrapped Ruby object */ #ifdef __PTHREAD__ - bool __get_up() const { - if (Swig::Director::_mutex_active) { - if (pthread_equal(Swig::Director::_mutex_thread, pthread_self())) { - bool up = _up; - __clear_up(); + bool swig_get_up() const { + if (Swig::Director::swig_mutex_active) { + if (pthread_equal(Swig::Director::swig_mutex_thread, pthread_self())) { + bool up = swig_up; + swig_clear_up(); return up; } } return false; } #else - bool __get_up() const { - bool up = _up; - _up = false; + bool swig_get_up() const { + bool up = swig_up; + swig_up = false; return up; } #endif - /* set the _up flag if the next method call should be directed to + /* set the swig_up flag if the next method call should be directed to * the c++ base class rather than the wrapped Ruby object */ #ifdef __PTHREAD__ - void __set_up() const { - pthread_mutex_lock(&Swig::Director::_mutex_up); - Swig::Director::_mutex_thread = pthread_self(); - Swig::Director::_mutex_active = true; - Swig::Director::_up = true; + void swig_set_up() const { + pthread_mutex_lock(&Swig::Director::swig_mutex_up); + Swig::Director::swig_mutex_thread = pthread_self(); + Swig::Director::swig_mutex_active = true; + Swig::Director::swig_up = true; } #else - void __set_up() const { - Swig::Director::_up = true; + void swig_set_up() const { + Swig::Director::swig_up = true; } #endif /* acquire ownership of the wrapped Ruby object (the sense of "disown" * is from Ruby) */ - void __disown() const { - if (!_disown) { - _disown = true; + void swig_disown() const { + if (!swig_disown_flag) { + swig_disown_flag = true; } } }; - bool Swig::Director::_up = false; + bool Swig::Director::swig_up = false; #ifdef __PTHREAD__ - MUTEX_INIT(Swig::Director::_mutex_up); - pthread_t Swig::Director::_mutex_thread; - int Swig::Director::_mutex_active = false; + MUTEX_INIT(Swig::Director::swig_mutex_up); + pthread_t Swig::Director::swig_mutex_thread; + bool Swig::Director::swig_mutex_active = false; #endif }