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/SWIG@9326 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
William S Fulton 2006-09-22 23:29:34 +00:00
commit d096cc1613
8 changed files with 262 additions and 176 deletions
Download patch file Download diff file Expand all files Collapse all files

3
CHANGES.current
View file

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

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

@ -12,6 +12,13 @@ public class runme
void run() 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 // These will give a warning if the %ignore is not working
public virtual void OverloadedMethod(int n, int xoffset, int yoffset) {} public virtual int OverloadedMethod(int n, int xoffset, int yoffset) { return 0; }
public virtual void OverloadedMethod(int n, int xoffset) {} public virtual int OverloadedMethod(int n, int xoffset) { return 0; }
public virtual void OverloadedMethod(int n) {} public virtual int OverloadedMethod(int n) { return 0; }
public virtual void ProtectedMethod(int n, int xoffset, int yoffset) {} public virtual int OverloadedProtectedMethod(int n, int xoffset, int yoffset) { return 0; }
public virtual void ProtectedMethod(int n, int xoffset) {} public virtual int OverloadedProtectedMethod(int n, int xoffset) { return 0; }
public virtual void ProtectedMethod(int n) {} 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
Examples/test-suite/director_ignore.i
View file

@ -1,13 +1,17 @@
%module(directors="1") director_ignore %module(directors="1") director_ignore
%warnfilter(SWIGWARN_LANG_DIRECTOR_ABSTRACT) DIgnoreOnlyConstructor;
%include "std_string.i" %include "std_string.i"
%feature("director"); %feature("director");
%ignore OverloadedMethod(int n, int xoffset = 0, int yoffset = 0); %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 DIgnoreConstructor(bool b);
%ignore DIgnoreOnlyConstructor(bool b); %ignore DIgnoreOnlyConstructor(bool b);
%ignore Pointers;
%ignore References;
%inline %{ %inline %{
@ -18,8 +22,26 @@ class DIgnores
virtual ~DIgnores() {} virtual ~DIgnores() {}
virtual void OverloadedMethod(int n, int xoffset = 0, int yoffset = 0) {} virtual void OverloadedMethod(int n, int xoffset = 0, int yoffset = 0) {}
virtual void OverloadedMethod(bool b) {} 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: 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 class DIgnoreConstructor
@ -37,16 +59,5 @@ class DIgnoreOnlyConstructor
DIgnoreOnlyConstructor(bool b) {} 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
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
Lib/java/std_map.i
View file

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

147
Source/Modules/csharp.cxx
View file

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

166
Source/Modules/java.cxx
View file

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

4
Source/Modules/lang.cxx
View file

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