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

%ignore director fixes

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@9326 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
William S Fulton 2006-09-22 23:29:34 +00:00
commit edd5bfeb1a
8 changed files with 262 additions and 176 deletions
Download patch file Download diff file Expand all files Collapse all files

3
SWIG/CHANGES.current
View file

@ -1,6 +1,9 @@
Version 1.3.30 (in progress)
============================
09/22/2006: wsfulton
Fix %ignore on director methods - Bugs #1546254, #1543533
09/20/2006: wsfulton
Fix %ignore on director constructors

35
SWIG/Examples/test-suite/csharp/director_ignore_runme.cs
View file

@ -12,6 +12,13 @@ public class runme
void run()
{
// Just check the classes can be instantiated and other methods work as expected
DIgnoresDerived a = new DIgnoresDerived();
if (a.Triple(5) != 15)
throw new Exception("Triple failed");
DAbstractIgnoresDerived b = new DAbstractIgnoresDerived();
if (b.Quadruple(5) != 20)
throw new Exception("Quadruple failed");
}
}
@ -22,13 +29,29 @@ class DIgnoresDerived : DIgnores
}
// These will give a warning if the %ignore is not working
public virtual void OverloadedMethod(int n, int xoffset, int yoffset) {}
public virtual void OverloadedMethod(int n, int xoffset) {}
public virtual void OverloadedMethod(int n) {}
public virtual int OverloadedMethod(int n, int xoffset, int yoffset) { return 0; }
public virtual int OverloadedMethod(int n, int xoffset) { return 0; }
public virtual int OverloadedMethod(int n) { return 0; }
public virtual void ProtectedMethod(int n, int xoffset, int yoffset) {}
public virtual void ProtectedMethod(int n, int xoffset) {}
public virtual void ProtectedMethod(int n) {}
public virtual int OverloadedProtectedMethod(int n, int xoffset, int yoffset) { return 0; }
public virtual int OverloadedProtectedMethod(int n, int xoffset) { return 0; }
public virtual int OverloadedProtectedMethod(int n) { return 0; }
}
class DAbstractIgnoresDerived : DAbstractIgnores
{
public DAbstractIgnoresDerived() : base()
{
}
// These will give a warning if the %ignore is not working
public virtual int OverloadedMethod(int n, int xoffset, int yoffset) { return 0; }
public virtual int OverloadedMethod(int n, int xoffset) { return 0; }
public virtual int OverloadedMethod(int n) { return 0; }
public virtual int OverloadedProtectedMethod(int n, int xoffset, int yoffset) { return 0; }
public virtual int OverloadedProtectedMethod(int n, int xoffset) { return 0; }
public virtual int OverloadedProtectedMethod(int n) { return 0; }
}
}

37
SWIG/Examples/test-suite/director_ignore.i
View file

@ -1,13 +1,17 @@
%module(directors="1") director_ignore
%warnfilter(SWIGWARN_LANG_DIRECTOR_ABSTRACT) DIgnoreOnlyConstructor;
%include "std_string.i"
%feature("director");
%ignore OverloadedMethod(int n, int xoffset = 0, int yoffset = 0);
%ignore ProtectedMethod(int n, int xoffset = 0, int yoffset = 0);
%ignore OverloadedProtectedMethod(int n, int xoffset = 0, int yoffset = 0);
%ignore DIgnoreConstructor(bool b);
%ignore DIgnoreOnlyConstructor(bool b);
%ignore Pointers;
%ignore References;
%inline %{
@ -18,8 +22,26 @@ class DIgnores
virtual ~DIgnores() {}
virtual void OverloadedMethod(int n, int xoffset = 0, int yoffset = 0) {}
virtual void OverloadedMethod(bool b) {}
virtual int Triple(int n) { return n*3; }
virtual int& References(int& n) { static int nn; nn=n; return nn; }
virtual int* Pointers(int* n) { static int nn; nn=*n; return &nn; }
protected:
virtual void ProtectedMethod(int n, int xoffset = 0, int yoffset = 0) {}
virtual void OverloadedProtectedMethod(int n, int xoffset = 0, int yoffset = 0) {}
virtual void OverloadedProtectedMethod() {}
};
class DAbstractIgnores
{
public:
virtual ~DAbstractIgnores() {}
virtual double OverloadedMethod(int n, int xoffset = 0, int yoffset = 0) = 0;
virtual double OverloadedMethod(bool b) = 0;
virtual int Quadruple(int n) { return n*4; }
virtual int& References(int& n) { static int nn; nn=n; return nn; }
virtual int* Pointers(int* n) { static int nn; nn=*n; return &nn; }
protected:
virtual double OverloadedProtectedMethod(int n, int xoffset = 0, int yoffset = 0) = 0;
virtual double OverloadedProtectedMethod() = 0;
};
class DIgnoreConstructor
@ -37,16 +59,5 @@ class DIgnoreOnlyConstructor
DIgnoreOnlyConstructor(bool b) {}
};
/*
class DAbstractIgnores
{
public:
virtual ~DAbstractIgnores() {}
virtual void OverloadedMethod(int n, int xoffset = 0, int yoffset = 0) = 0;
virtual void OverloadedMethod(bool b) = 0;
};
*/
%}

40
SWIG/Examples/test-suite/java/director_ignore_runme.java Executable file
View file

@ -0,0 +1,40 @@
import director_ignore.*;
public class director_ignore_runme {
static {
try {
System.loadLibrary("director_ignore");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
System.exit(1);
}
}
public static void main(String argv[])
{
// Just check the classes can be instantiated and other methods work as expected
DIgnoresDerived a = new DIgnoresDerived();
if (a.Triple(5) != 15)
throw new RuntimeException("Triple failed");
DAbstractIgnoresDerived b = new DAbstractIgnoresDerived();
if (b.Quadruple(5) != 20)
throw new RuntimeException("Quadruple failed");
}
}
class DIgnoresDerived extends DIgnores
{
public DIgnoresDerived()
{
super();
}
}
class DAbstractIgnoresDerived extends DAbstractIgnores
{
public DAbstractIgnoresDerived()
{
super();
}
}

6
SWIG/Lib/java/std_map.i
View file

@ -26,6 +26,10 @@ namespace std {
template<class K, class T> class map {
// add typemaps here
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef K key_type;
typedef T mapped_type;
map();
map(const map<K,T> &);
@ -33,7 +37,7 @@ namespace std {
bool empty() const;
void clear();
%extend {
T& get(const K& key) throw (std::out_of_range) {
const T& get(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key);
if (i != self->end())
return i->second;

147
SWIG/Source/Modules/csharp.cxx
View file

@ -586,6 +586,8 @@ class CSHARP : public Language {
Hash *new_udata;
String *key = NewStringf("%s|%s", imclass_method, decl);
++curr_class_dmethod;
/* Do we know about this director class already? */
if ((udata = Getattr(dmethods_table, key))) {
Delete(key);
@ -2989,7 +2991,7 @@ class CSHARP : public Language {
String *callback_code = NewString("");
String *imcall_args = NewString("");
int gencomma = 0;
bool ignored_method = GetFlag(n, "feature:ignore") ? true : false;
// Kludge Alert: functionWrapper sets sym:overload properly, but it
// isn't at this point, so we have to manufacture it ourselves. At least
@ -3005,9 +3007,10 @@ class CSHARP : public Language {
c_classname = classname;
if (returntype) {
if (!is_void) {
qualified_return = SwigType_rcaststr(returntype, "result");
qualified_return = SwigType_rcaststr(returntype, "result");
if (!is_void && !ignored_method) {
if (!SwigType_isclass(returntype)) {
if (!(SwigType_ispointer(returntype) || SwigType_isreference(returntype))) {
Wrapper_add_localv(w, "result", SwigType_lstr(returntype, "result"), NIL);
@ -3051,38 +3054,33 @@ class CSHARP : public Language {
Delete(vt);
}
}
}
/* Create the intermediate class wrapper */
Parm *tp = NewParmFromNode(returntype, empty_str, n);
/* Create the intermediate class wrapper */
Parm *tp = NewParmFromNode(returntype, empty_str, n);
tm = Swig_typemap_lookup_new("imtype", tp, "", 0);
if (tm) {
String *imtypeout = Getattr(tp,"tmap:imtype:out"); // the type in the imtype typemap's out attribute overrides the type in the typemap
if (imtypeout)
tm = imtypeout;
Printf(callback_def, " private %s SwigDirector%s(", tm, symname);
Printf(director_delegate_definitions, " public delegate %s", tm);
} else {
Swig_warning(WARN_CSHARP_TYPEMAP_CSTYPE_UNDEF, input_file, line_number,
"No imtype typemap defined for %s\n", SwigType_str(returntype,0));
}
tm = Swig_typemap_lookup_new("imtype", tp, "", 0);
if (tm) {
String *imtypeout = Getattr(tp,"tmap:imtype:out"); // the type in the imtype typemap's out attribute overrides the type in the typemap
if (imtypeout)
tm = imtypeout;
Printf(callback_def, " private %s SwigDirector%s(", tm, symname);
if (!ignored_method)
Printf(director_delegate_definitions, " public delegate %s", tm);
} else {
Printf(callback_def, " private void SwigDirector%s(", symname);
Printf(director_delegate_definitions, " public delegate void");
Swig_warning(WARN_CSHARP_TYPEMAP_CSTYPE_UNDEF, input_file, line_number,
"No imtype typemap defined for %s\n", SwigType_str(returntype,0));
}
Parm *retpm = NewParmFromNode(returntype, empty_str, n);
if ((c_ret_type = Swig_typemap_lookup_new("ctype", retpm, "", 0))) {
if (!is_void) {
if (!is_void && !ignored_method) {
String *jretval_decl = NewStringf("%s jresult", c_ret_type);
Wrapper_add_localv(w, "jresult", jretval_decl, " = 0", NIL);
Delete(jretval_decl);
}
Printf(director_callback_typedefs, " typedef %s", c_ret_type);
} else {
Swig_warning(WARN_CSHARP_TYPEMAP_CTYPE_UNDEF, input_file, line_number,
"No ctype typemap defined for %s\n", SwigType_str(returntype,0));
@ -3115,8 +3113,8 @@ class CSHARP : public Language {
Swig_typemap_attach_parms("csdirectorin", l, 0);
/* Preamble code */
Printf(w->code, "if (!swig_callback%s) {\n", overloaded_name);
if (!ignored_method)
Printf(w->code, "if (!swig_callback%s) {\n", overloaded_name);
if (!pure_virtual) {
if (is_void) {
@ -3129,16 +3127,10 @@ class CSHARP : public Language {
}
} else {
Printf(w->code, " throw Swig::DirectorPureVirtualException(\"%s::%s\");\n", c_classname, name);
/* Make sure that we return something in the case of a pure
* virtual method call for syntactical reasons. */
if (!is_void)
Printf(w->code, "return %s;", qualified_return);
else
Printf(w->code, "return;\n");
}
Printf(w->code, "} else {\n");
if (!ignored_method)
Printf(w->code, "} else {\n");
/* Go through argument list, convert from native to Java */
for (p=l; p; /* empty */) {
@ -3175,7 +3167,8 @@ class CSHARP : public Language {
/* Add to local variables */
Printf(c_decl, "%s %s", c_param_type, arg);
Wrapper_add_localv(w, arg, c_decl, (!(SwigType_ispointer(pt) || SwigType_isreference(pt)) ? "" : "= 0"), NIL);
if (!ignored_method)
Wrapper_add_localv(w, arg, c_decl, (!(SwigType_ispointer(pt) || SwigType_isreference(pt)) ? "" : "= 0"), NIL);
/* Add input marshalling code */
if ((desc_tm = Swig_typemap_lookup_new("directorin", tp, "", 0))
@ -3184,7 +3177,8 @@ class CSHARP : public Language {
Replaceall(tm,"$input", arg);
if (Len(tm))
Printf(w->code,"%s\n", tm);
if (!ignored_method)
Printf(w->code,"%s\n", tm);
Delete(tm);
@ -3348,45 +3342,42 @@ class CSHARP : public Language {
Printf(callback_code, " }\n");
Delete(upcall);
/* Emit the actual upcall through */
UpcallData *udata = addUpcallMethod(imclass_dmethod, symname, decl, overloaded_name);
String *methid = Getattr(udata, "class_methodidx");
if (!ignored_method) {
if (!is_void) Printf(w->code, "jresult = (%s) ", c_ret_type);
Printf(w->code, "swig_callback%s(%s);\n",
overloaded_name, jupcall_args);
if (!is_void) Printf(w->code, "jresult = (%s) ", c_ret_type);
Printf(w->code, "swig_callback%s(%s);\n",
overloaded_name, jupcall_args);
if (!is_void) {
String *jresult_str = NewString("jresult");
String *result_str = NewString("result");
Parm *tp = NewParmFromNode(returntype, result_str, n);
if (!is_void) {
String *jresult_str = NewString("jresult");
String *result_str = NewString("result");
Parm *tp = NewParmFromNode(returntype, result_str, n);
/* Copy jresult into result... */
if ((tm = Swig_typemap_lookup_new("directorout", tp, result_str, w))) {
addThrows(n, "tmap:directorout", tp);
Replaceall(tm,"$source", jresult_str); /* deprecated */
Replaceall(tm,"$target", result_str); /* deprecated */
Replaceall(tm,"$arg", jresult_str); /* deprecated? */
Replaceall(tm,"$input", jresult_str);
Printf(w->code, "%s\n", tm);
} else {
Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
"Unable to use return type %s in director method %s::%s (skipping method).\n", SwigType_str(returntype, 0), classname, name);
output_director = false;
}
/* Copy jresult into result... */
if ((tm = Swig_typemap_lookup_new("directorout", tp, result_str, w))) {
addThrows(n, "tmap:directorout", tp);
Replaceall(tm,"$source", jresult_str); /* deprecated */
Replaceall(tm,"$target", result_str); /* deprecated */
Replaceall(tm,"$arg", jresult_str); /* deprecated? */
Replaceall(tm,"$input", jresult_str);
Printf(w->code, "%s\n", tm);
} else {
Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
"Unable to use return type %s in director method %s::%s (skipping method).\n", SwigType_str(returntype, 0), classname, name);
output_director = false;
Delete(tp);
Delete(jresult_str);
Delete(result_str);
}
Delete(tp);
Delete(jresult_str);
Delete(result_str);
/* Terminate wrapper code */
Printf(w->code, "}\n");
if (!is_void)
Printf(w->code, "return %s;", qualified_return);
}
/* Terminate wrapper code */
Printf(w->code, "}\n");
if (!is_void)
Printf(w->code, "return %s;", qualified_return);
Printf(w->code, "}");
// We expose protected methods via an extra public inline method which makes a straight call to the wrapped class' method
@ -3412,7 +3403,8 @@ class CSHARP : public Language {
} else {
Replaceall(w->code,"$null","");
}
Printv(director_delegate_callback, "\n", callback_def, callback_code, NIL);
if (!ignored_method)
Printv(director_delegate_callback, "\n", callback_def, callback_code, NIL);
if (!Getattr(n,"defaultargs")) {
Wrapper_print(w, f_directors);
Printv(f_directors_h, declaration, NIL);
@ -3420,14 +3412,20 @@ class CSHARP : public Language {
}
}
Printf(director_callback_typedefs, " (SWIGSTDCALL* SWIG_Callback%s_t)(", methid);
Printf(director_callback_typedefs, "%s);\n", callback_typedef_parms);
Printf(director_callbacks, " SWIG_Callback%s_t swig_callback%s;\n", methid, overloaded_name);
if (!ignored_method) {
/* Emit the actual upcall through */
UpcallData *udata = addUpcallMethod(imclass_dmethod, symname, decl, overloaded_name);
String *methid = Getattr(udata, "class_methodidx");
Printf(director_delegate_definitions, " SwigDelegate%s_%s(%s);\n", classname, methid, delegate_parms);
Printf(director_delegate_instances, " private SwigDelegate%s_%s swigDelegate%s;\n", classname, methid, methid);
Printf(director_method_types, " private static Type[] swigMethodTypes%s = new Type[] { %s };\n", methid, proxy_method_types);
Printf(director_connect_parms, "SwigDirector%s%s delegate%s", classname, methid, methid);
Printf(director_callback_typedefs, " typedef %s (SWIGSTDCALL* SWIG_Callback%s_t)(", c_ret_type, methid);
Printf(director_callback_typedefs, "%s);\n", callback_typedef_parms);
Printf(director_callbacks, " SWIG_Callback%s_t swig_callback%s;\n", methid, overloaded_name);
Printf(director_delegate_definitions, " SwigDelegate%s_%s(%s);\n", classname, methid, delegate_parms);
Printf(director_delegate_instances, " private SwigDelegate%s_%s swigDelegate%s;\n", classname, methid, methid);
Printf(director_method_types, " private static Type[] swigMethodTypes%s = new Type[] { %s };\n", methid, proxy_method_types);
Printf(director_connect_parms, "SwigDirector%s%s delegate%s", classname, methid, methid);
}
Delete(qualified_return);
Delete(c_ret_type);
@ -3439,7 +3437,6 @@ class CSHARP : public Language {
Delete(callback_code);
DelWrapper(w);
++curr_class_dmethod;
return status;
}

166
SWIG/Source/Modules/java.cxx
View file

@ -643,6 +643,8 @@ class JAVA : public Language {
Hash *new_udata;
String *key = NewStringf("%s|%s", imclass_method, decl);
++curr_class_dmethod;
/* Do we know about this director class already? */
if ((udata = Getattr(dmethods_table, key))) {
Delete(key);
@ -3019,7 +3021,7 @@ class JAVA : public Language {
String *imcall_args = NewString("");
int gencomma = 0;
int classmeth_off = curr_class_dmethod - first_class_dmethod;
bool ignored_method = GetFlag(n, "feature:ignore") ? true : false;
// Kludge Alert: functionWrapper sets sym:overload properly, but it
// isn't at this point, so we have to manufacture it ourselves. At least
@ -3035,9 +3037,10 @@ class JAVA : public Language {
c_classname = classname;
if (returntype) {
if (!is_void) {
qualified_return = SwigType_rcaststr(returntype, "result");
qualified_return = SwigType_rcaststr(returntype, "result");
if (!is_void && (!ignored_method || pure_virtual)) {
if (!SwigType_isclass(returntype)) {
if (!(SwigType_ispointer(returntype) || SwigType_isreference(returntype))) {
Wrapper_add_localv(w, "result", SwigType_lstr(returntype, "result"), NIL);
@ -3081,19 +3084,18 @@ class JAVA : public Language {
Delete(vt);
}
}
}
/* Create the intermediate class wrapper */
Parm *tp = NewParmFromNode(returntype, empty_str, n);
/* Create the intermediate class wrapper */
Parm *tp = NewParmFromNode(returntype, empty_str, n);
tm = Swig_typemap_lookup_new("jtype", tp, "", 0);
if (tm) {
Printf(callback_def, " public static %s %s(%s self", tm, imclass_dmethod, classname);
} else {
Swig_warning(WARN_JAVA_TYPEMAP_JTYPE_UNDEF, input_file, line_number,
"No jtype typemap defined for %s\n", SwigType_str(returntype,0));
}
} else
Printf(callback_def, " public static void %s(%s self", imclass_dmethod, classname);
tm = Swig_typemap_lookup_new("jtype", tp, "", 0);
if (tm) {
Printf(callback_def, " public static %s %s(%s self", tm, imclass_dmethod, classname);
} else {
Swig_warning(WARN_JAVA_TYPEMAP_JTYPE_UNDEF, input_file, line_number,
"No jtype typemap defined for %s\n", SwigType_str(returntype,0));
}
/* Get the JNI field descriptor for this return type, add the JNI field descriptor
to jniret_desc */
@ -3104,7 +3106,7 @@ class JAVA : public Language {
String *jdesc;
Parm *tp = NewParmFromNode(c_ret_type, empty_str, n);
if (!is_void) {
if (!is_void && !ignored_method) {
String *jretval_decl = NewStringf("%s jresult", c_ret_type);
Wrapper_add_localv(w, "jresult", jretval_decl, " = 0", NIL);
Delete(jretval_decl);
@ -3177,19 +3179,20 @@ class JAVA : public Language {
Swig_typemap_attach_parms("directorin", l, 0);
Swig_typemap_attach_parms("javadirectorin", l, 0);
/* Add Java environment pointer to wrapper */
String *jenvstr = NewString("jenv");
String *jobjstr = NewString("jobj");
if (!ignored_method) {
/* Add Java environment pointer to wrapper */
String *jenvstr = NewString("jenv");
String *jobjstr = NewString("jobj");
Wrapper_add_localv(w, "jnienv", "JNIEnvWrapper", "jnienv(this)", NIL, NIL);
Wrapper_add_localv(w, jenvstr, "JNIEnv *", jenvstr, "= jnienv.getJNIEnv()", NIL);
Wrapper_add_localv(w, jobjstr, "jobject ", jobjstr, "= (jobject) NULL", NIL);
Delete(jenvstr);
Delete(jobjstr);
Wrapper_add_localv(w, "jnienv", "JNIEnvWrapper", "jnienv(this)", NIL, NIL);
Wrapper_add_localv(w, jenvstr, "JNIEnv *", jenvstr, "= jnienv.getJNIEnv()", NIL);
Wrapper_add_localv(w, jobjstr, "jobject ", jobjstr, "= (jobject) NULL", NIL);
Delete(jenvstr);
Delete(jobjstr);
/* Preamble code */
Printf(w->code, "if (!swig_override[%d]) {\n", classmeth_off);
/* Preamble code */
Printf(w->code, "if (!swig_override[%d]) {\n", classmeth_off);
}
if (!pure_virtual) {
if (is_void) {
@ -3201,9 +3204,8 @@ class JAVA : public Language {
Delete(super_call);
}
} else {
Printf(w->code, "SWIG_JavaThrowException(jenv, SWIG_JavaDirectorPureVirtual,\n");
Printf(w->code, " \"Attempted to invoke pure virtual method %s::%s.\");\n",
c_classname, name);
Printf(w->code, "SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, ");
Printf(w->code, "\"Attempted to invoke pure virtual method %s::%s.\");\n", c_classname, name);
/* Make sure that we return something in the case of a pure
* virtual method call for syntactical reasons. */
@ -3213,9 +3215,11 @@ class JAVA : public Language {
Printf(w->code, "return;\n");
}
Printf(w->code, "}\n");
Printf(w->code, "jobj = swig_get_self(jenv);\n");
Printf(w->code, "if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) {\n");
if (!ignored_method) {
Printf(w->code, "}\n");
Printf(w->code, "jobj = swig_get_self(jenv);\n");
Printf(w->code, "if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) {\n");
}
/* Start the Java field descriptor for the intermediate class's upcall (insert self object) */
Parm *tp = NewParmFromNode(c_classname, empty_str, n);
@ -3266,7 +3270,8 @@ class JAVA : public Language {
/* Add to local variables */
Printf(c_decl, "%s %s", c_param_type, arg);
Wrapper_add_localv(w, arg, c_decl, (!(SwigType_ispointer(pt) || SwigType_isreference(pt)) ? "" : "= 0"), NIL);
if (!ignored_method)
Wrapper_add_localv(w, arg, c_decl, (!(SwigType_ispointer(pt) || SwigType_isreference(pt)) ? "" : "= 0"), NIL);
/* Add input marshalling code and update JNI field descriptor */
if ((desc_tm = Swig_typemap_lookup_new("directorin", tp, "", 0))
@ -3282,7 +3287,8 @@ class JAVA : public Language {
Replaceall(tm,"$input", arg);
if (Len(tm))
Printf(w->code,"%s\n", tm);
if (!ignored_method)
Printf(w->code,"%s\n", tm);
Delete(tm);
@ -3437,57 +3443,59 @@ class JAVA : public Language {
Printf(callback_code, " }\n");
Delete(upcall);
/* Emit the actual upcall through */
String *imclass_desc = NewStringf("(%s)%s", jnidesc, jniret_desc);
String *class_desc = NewStringf("(%s)%s", classdesc, classret_desc);
UpcallData *udata = addUpcallMethod(imclass_dmethod, symname, imclass_desc, class_desc, decl);
String *methid = Getattr(udata, "imclass_methodidx");
String *methop = getUpcallJNIMethod(jniret_desc);
if (!ignored_method) {
/* Emit the actual upcall through */
String *imclass_desc = NewStringf("(%s)%s", jnidesc, jniret_desc);
String *class_desc = NewStringf("(%s)%s", classdesc, classret_desc);
UpcallData *udata = addUpcallMethod(imclass_dmethod, symname, imclass_desc, class_desc, decl);
String *methid = Getattr(udata, "imclass_methodidx");
String *methop = getUpcallJNIMethod(jniret_desc);
if (!is_void) Printf(w->code, "jresult = (%s) ", c_ret_type);
Printf(w->code, "jenv->%s(Swig::jclass_%s, Swig::director_methids[%s], %s);\n",
methop, imclass_name, methid, jupcall_args);
if (!is_void) Printf(w->code, "jresult = (%s) ", c_ret_type);
Printf(w->code, "if (jenv->ExceptionOccurred()) return $null;\n");
Printf(w->code, "jenv->%s(Swig::jclass_%s, Swig::director_methids[%s], %s);\n",
methop, imclass_name, methid, jupcall_args);
if (!is_void) {
String *jresult_str = NewString("jresult");
String *result_str = NewString("result");
Parm *tp = NewParmFromNode(returntype, result_str, n);
Printf(w->code, "if (jenv->ExceptionOccurred()) return $null;\n");
/* Copy jresult into result... */
if ((tm = Swig_typemap_lookup_new("directorout", tp, result_str, w))) {
addThrows(n, "tmap:directorout", tp);
Replaceall(tm,"$source", jresult_str); /* deprecated */
Replaceall(tm,"$target", result_str); /* deprecated */
Replaceall(tm,"$arg", jresult_str); /* deprecated? */
Replaceall(tm,"$input", jresult_str);
Printf(w->code, "%s\n", tm);
} else {
Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
"Unable to use return type %s in director method %s::%s (skipping method).\n", SwigType_str(returntype, 0), classname, name);
output_director = false;
if (!is_void) {
String *jresult_str = NewString("jresult");
String *result_str = NewString("result");
Parm *tp = NewParmFromNode(returntype, result_str, n);
/* Copy jresult into result... */
if ((tm = Swig_typemap_lookup_new("directorout", tp, result_str, w))) {
addThrows(n, "tmap:directorout", tp);
Replaceall(tm,"$source", jresult_str); /* deprecated */
Replaceall(tm,"$target", result_str); /* deprecated */
Replaceall(tm,"$arg", jresult_str); /* deprecated? */
Replaceall(tm,"$input", jresult_str);
Printf(w->code, "%s\n", tm);
} else {
Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
"Unable to use return type %s in director method %s::%s (skipping method).\n", SwigType_str(returntype, 0), classname, name);
output_director = false;
}
Delete(tp);
Delete(jresult_str);
Delete(result_str);
}
Delete(tp);
Delete(jresult_str);
Delete(result_str);
Delete(imclass_desc);
Delete(class_desc);
/* Terminate wrapper code */
Printf(w->code, "} else {\n");
Printf(w->code, "SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, \"null upcall object\");\n");
Printf(w->code, "}\n");
Printf(w->code, "if (jobj) jenv->DeleteLocalRef(jobj);\n");
if (!is_void)
Printf(w->code, "return %s;", qualified_return);
}
Delete(imclass_desc);
Delete(class_desc);
/* Terminate wrapper code */
Printf(w->code, "} else {\n");
Printf(w->code, "SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, \"null upcall object\");\n");
Printf(w->code, "}\n");
Printf(w->code, "if (jobj) jenv->DeleteLocalRef(jobj);\n");
if (!is_void)
Printf(w->code, "return %s;", qualified_return);
Printf(w->code, "}");
// We expose protected methods via an extra public inline method which makes a straight call to the wrapped class' method
@ -3513,7 +3521,8 @@ class JAVA : public Language {
} else {
Replaceall(w->code,"$null","");
}
Printv(imclass_directors, callback_def, callback_code, NIL);
if (!GetFlag(n, "feature:ignore"))
Printv(imclass_directors, callback_def, callback_code, NIL);
if (!Getattr(n,"defaultargs")) {
Wrapper_print(w, f_directors);
Printv(f_directors_h, declaration, NIL);
@ -3531,7 +3540,6 @@ class JAVA : public Language {
Delete(callback_code);
DelWrapper(w);
++curr_class_dmethod;
return status;
}

4
SWIG/Source/Modules/lang.cxx
View file

@ -1954,8 +1954,8 @@ int Language::classDirectorMethods(Node *n) {
item = k.item;
String *method = Getattr(item, "methodNode");
String *fqdname = Getattr(item, "fqdname");
if (GetFlag(method,"feature:ignore"))
continue;
// if (GetFlag(method,"feature:ignore"))
// continue;
if (GetFlag(method, "feature:nodirector"))
continue;