jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
swig/SWIG/CHANGES.current
John Lenz 0e57357472 Fix a few bugs in the tcl module related to clientdata propagation. 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@6357 626c5289-ae23-0410-ae9c-e8d60b6d4f22
2004-10-07 02:31:14 +00:00

425 lines
14 KiB
Text
Raw Blame History

Version 1.3.23 (in progress)
============================
10/06/2004: wuzzeb (John Lenz)
[TCL]
- Fix bug reported by William A. Hoffman propagating clientdata
between modules. Added clientdata_prop.multicpptest to check for
this bug. The fix involved the following changes:
+ SwigType_clientdata_collect does not need to check
types in r_resolved because we only want to propagate clientdata
to typedefed classes, and r_mangled already takes care of typedefs.
+ SWIG_TypeRegister now copies the clientdata field correctly
+ Move SWIG_Guile_PropagateClientData function from guile module
into common.swg, because we need to call it from both guile and tcl.
+ Add base_names to swig_class to delay the lookup of bases. SWIG
now exports the base names and only when the base swig_class is
needed is SWIG_TypeQuery(name)->clientdata looked up.
- conversion_ns_template testsuite test was failing because
the name of the wrapped constructor function was not calculated
correctly for structs. Fixed.
10/06/2004: wsfulton
Fixes for default arguments used in directors - in virtual
methods and director constructors.
10/06/2004: mmatus
Fix the __cplusplus macro, and bug 1041170.
Now it is working as supposed, ie, you can safetly use
#ifdef __cplusplus
...
all over swig, including inside %defines and %{ %} bodies.
*** POTENTIAL INCOMPATIBILITY ***
The old trick of using
#if __cplusplus
doesn't work any more. So, if you have your own typemaps
using that syntax, you will need to migrate them use
"#ifdef __cplusplus".
10/05/2004: wuzzeb (John Lenz)
- Reorganize how runtime type information is stored and shared
between modules. For chicken and mzscheme, I removed
the ability to use runtime libraries, while perl, tcl, python, and
ruby default to using the new method but can go back to the old
method by declaring SWIG_ALLOW_RUNTIME.
- line 582 in mzscheme.cxx was generating a segfault on
imports.multicpptest, so I fixed it.
10/05/2004: wsfulton
Fixes for %extend and overloaded static methods with default
arguments.
10/05/2004: mmatus
- [python] Fix director + method with 'empty' throw, ie
struct A {
virtual int foo() throw();
};
other languages should also easy to fix, look for
Getattr(n,"throw") in python.cxx.
- Fix director + destructor with 'empty' throw
struct A {
virtual ~A() throw();
};
- Now SWIG_FEAUTURES parse all and the same options you
can pass to swig in the command line.
Maybe we should rename it to SWIG_OPTIONS
- New command line flag: -features <list>, as in
swig -features autodoc=3,director
ie, any global feature can be initialized from the
command line. This is mainly for testing, but user
can also take advantage of it.
10/04/2004: mmatus
- Properly qualify type in syntax as 'long(2)' or 'Foo()',
this solve old problem with default args, and probably
other problems around. However, the default arg problem
was also already solved by William (see bellow).
- Fix feature_set and feature_get methods. Before
they look from particular to general and keep the first
feature found. This didn't work well with templates.
Now the methods look from general to particular, and
override any found feature.
- Fix missing features for default const/dest, by really
'creating' the methods and applying the features.
- Fix return_const_value.i case by adding SwigValueWrapper<const T>
specialization.
- Fix %extend + overload, including overloading actual
class methods.
- Adding more cases in related files in the test-suite.
10/04/2004: wsfulton
Changes to the way default arguments are wrapped. Previously a single
method was generated for each method that had default arguments. If
a method had 5 arguments, say, of which 1 had a default argument
then the call to the wrapped method would pass 5 arguments. The default
value was copied into the wrapper method and used if the scripting
language passed just 4 arguments. However, this was flawed as the
default argument sometimes does not have global access, for example
SWIG would generate code that couldn't compile when wrapping:
class Tricky {
public:
void foo(int val = privatevalue);
void bar(int val = Tricky::getDefault());
private:
static int getDefault();
enum { privatevalue = 200 };
};
Also bugs in resolving symbols generated code that wouldn't compile, for example
(probably fixable though):
namespace Space {
class Klass {
};
Klass constructorcall(const Klass& k = Klass());
}
The approach also does not work for statically typed languages (C# and Java)
as these languages do not allow methods to have variable number of arguments.
Although C# has a mechanism to pass a variable number of arguments they
must be of the same type and are more like varargs.
The new approach solves the above problems and wraps methods with default
arguments as if the method was overloaded. So SWIG will now treat
void foo(int val=0);
as if it had parsed:
void foo(int);
void foo();
The code generated is then exactly the same as if SWIG had parsed the two
overloaded methods. The scripting languages count the arguments passed and call
the appropriate method, just like overloaded methods. C# and Java are now able
to properly wrap methods with default arguments by generating extra methods,
again as if the method was overloaded, so for:
void bar(string s="hello", double d=10.0, int i=0);
the following proxy methods are generated:
void bar(string s, double d, int i);
void bar(string s, double d);
void bar(string s);
void bar();
The new approach comes with a couple of minor knock on effects.
1) SWIG support for default arguments for C (not C++) code no longer works.
Previously you could have this interface:
%{
void foo(int val);
%}
void foo(int val=0);
and call the wrapped method from a scripting language and pass no arguments
whereupon the default of 0 was used. You can get the same behaviour for C
code by using the "default" typemap:
%typemap(default) int val "$1 = 0;";
%{
void foo(int val);
%}
void foo(int val);
or you could of course compile your code as C++ if you want C++ features :) :
%{
void foo(int val=0);
%}
void foo(int val=0);
A couple of SWIG's libraries used this C extension and these have been modified
to use the "default" typemap. The "default" typemap is thus unchanged (and still
is not and is not fully supported by C# and Java, and is likely to remain so).
2) All features (%feature, %rename, %ignore etc) no longer work as if the method
with default arguments is just one method. For example, previously
%ignore foo(int);
would have ignored the method completely. Now it will only ignore foo(int) but
not the extra foo() method. Instead use:
%ignore foo;
to ignore them all. or
%ignore foo(int);
%ignore foo();
This of course allows one to fine tune the wrapping, for example one could use:
%rename(fooint) foo(int);
%rename(foodefaults) foo();
void foo(int val=0);
and call them from any language like so:
fooint(200)
foodefaults()
or for example ignore the extra overloaded method, so the defaults cannot be used:
%ignore foo();
void foo(int val=0);
*** POTENTIAL INCOMPATIBILITY ***
10/2/2004: mmatus
[Python]
- More cleaning up and uniformation on the Python Lib
- Added Robin's docstring patch, plus some fixes, plus
some extensions, see autodoc.i example in the test-suite,
and try using %feature("autodoc","extended").
This patch is not a complete solution for the
documentation problem, just enough to inform python about
the parameter list.
The expected swig documentation support is far far away yet.
10/1/2004: mmatus
- Fix the %callback feature (only used in ruby and python examples,
by now, but it should be generic), now member callbacks
are working again
- Fix wrapping of functions pointers like
std::ostream& std::endl(std::ostream&);
ie, the ones that return references or enums.
[Python] Add the %pythoncallback directive, which is
an improved version of %callback, ie,
%pythoncallback(1) foo;
%pythoncallback(1) A::bar;
%pythoncallback(1) A::barm;
int foo(int a) {
return a;
}
struct A
{
static int bar(int a);
int barm(int a);
};
int foobar(int a, int (*pf)(int a));
in python you can use
foo(2)
foobar(2,foo)
A.bar(2)
foobar(2,A.bar)
ie, no additional pointer elements are created, and
the original 'foo' and 'A.bar' can be used as parameters.
In the case of member fucntion however, still you need
to use the special variable Class::<fnc_name>_cb_ptr, ie:
foobarm(3, a, A.barm_cb_ptr)
we will try to fix this situation also, but later.
[Python] Add more elements from the STL library, now
you can use
import std
std.cout << "hello " << 123 << std.endl
[Python] Fix in/out return mechanism, now swig will behave
as 1.3.21 but using a python list when needed. The problem
is that the types std::pair,std::vector,etc, use tuples,
and they interfer with the previous inout tuple type.
By using lists we solve the conflicts, swig acts as before,
but returns a list when more than one parameter are using
the OUT typemap. See the new inout.i example in the
test-suite.
*** POTENTIAL INCOMPATIBILITY FOR PYTHON MODULE ***
[Python] Much better error messages for bad arguments, now
you always get the argument number where the error occurred.
09/27/2004: wsfulton
Patch from Bill Clarke -
1) Warning emitted when -importall and -includeall is used together,
with -includeall taking precedence.
2) Ensure SWIGIMPORTED is always defined when a file is being
imported with %import. Note that this is not the same as SWIGIMPORT,
which gets defined in all generated wrapper files.
09/26/2004: mmatus
- add %feature("exceptionclass") to identify a class used
as exception. Before swig identified and marked a class
using the "cplus:exceptionclass" attribute. However, the
class needed to appear on an throw() statement. Now
swig keeps trying to identify the exception classes, as
before, but it also allows the user to mark a class by
using the %feature explicitly. (mostly relevant for
python and chicken)
[Python]
- fix -modern option + exceptions, which mix old class
style with the new one. So, we always need to emit
the "nonmodern" python code.
- add the "python:nondynamic" feature and its handler
now if you have
%pythonnondynamic(1) A;
struct A {
int a;
int b;
};
then, in the python side
aa = A()
aa.a = 1 # ok
aa.b = 2 # ok
aa.c = 3 # error, the class can not be extended dynamically.
Since this is a feature, you can use
%pythonnondynamic(1);
or
%pythondynamic(0);
to force all the wrapped classes to be "nondynamic" ones.
The default, as in regular python, is that all the wrapped
classes are dynamics. So, careful with your spelling.
09/14/2004: mmatus
- Support the -I- option.
- Differentiate between %include <file> and %include "file".
This fix several corner cases.
[Python] Several patches:
- Normalize the Lib file names:
*.swg internal files,
*.i user files.
- Fix Char[ANY] typemaps, so they also delete any extra '\0' chars,
now they behave as before (1.3.21). Still, you can use
the SWIG_PRESERVE_CARRAY_SIZE macro if you need to
preserve the original size (see pystrbase.swg).
- Add the Char FIXSIZE[ANY] typemaps, to preserve the
original C array sizes (see above). Though, you can't
use them yet since %apply and arrays are not working
together.
- Add pyfragments.swg, now the user can add fragments
to override the default ones.
>>>>>>> 1.292
09/10/2004: wsfulton
Patch from Bill Clarke which fixes spurious preprocessor bug which
shows on Solaris and gcc, eg:
Warning(202): Could not evaluate '!defined(SWIGJAVA) &&
!(defined(SWIGCSHARP)'
Also fixes a bug where '#if "a" == "b" == 1' wouldn't have worked
09/10/2004: wsfulton
Restored multiple build directories for the test-suite. Patch from
Bill Clarke.
09/06/2004: wsfulton
Added the missing runtime.dsp Visual Studio project files for the
import examples to work.
Reference in a new issue View git blame Copy permalink