jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

- Compliance with ISO/IEC 14882:1998(E) 17.4.3.1.2 -> eg double underscores removed

Browse source 
- 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
This commit is contained in:
William S Fulton 2003-09-22 22:55:17 +00:00
commit f4fac221fa
5 changed files with 170 additions and 176 deletions
Download patch file Download diff file Expand all files Collapse all files

48
Lib/java/director.swg
View file

@ -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;
}
};
}

92
Lib/ocaml/director.swg
View file

@ -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
}

111
Lib/python/director.swg
View file

@ -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
}

2
Lib/python/python.swg
View file

@ -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();
}
}
}

93
Lib/ruby/director.swg
View file

@ -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
}