The proxy layer, and all the extra complexity associated with it, seemed to be
only necessary in order to try to allow using the same name for the wrapped
global functions as were used for them in the original C or C++ code being
wrapped. However this could simply never work in all cases, notably it didn't
work at all when using ELF shared libraries under Unix as the functions with
the same name defined in the main program were interposed and replaced the
functions defined in the shared library, meaning that the proxy function foo()
called wrapper function _wrap_foo() which called back into proxy function
foo() itself again, resulting in guaranteed stack overflow. The only possible
way to fix this would be to use "protected" ELF visibility for the original
functions, but this is not always possible (e.g. if the sources of the
original library are not available) and not simple even when it is and,
besides, protected visibility has its own problems -- notably by making it
impossible to hook the library functions when you actually want to do it.
Besides, proxy-based approach simply couldn't work at all when using static
linking as it resulted in two copies of the function with the same name
Most importantly, however, the main task of this module is to wrap C++
classes, not C functions, and renaming them in the wrapper is not necessary at
all in this case as there is no conflict with the original names in this case.
So simply drop the idea of generating a separate proxy header and generate a
header declaring the functions declared in the wrapper instead and, also, do
not give them "_wrap_" prefix whenever possible, i.e. only do it for the
global functions.
This simplifies SWIG code itself and makes it simpler to use its output as
it's not necessary to link both with the wrapper (dynamically) and with the
proxy (statically) and it's not enough to link with the wrapper only and it
can be done in any way (i.e. either statically or dynamically).
As a side effect of this change, Swig_name_proxy() is not necessary any more
and was removed, eliminating the only difference with the master branch in any
source file other than c.cxx itself.
* char-escaping:
Add missing string_constant.i testcase
changes file update for char wrappers
C# char wrappers fixes for enum values, static const member char values and %csconst
D testing added for %dmanifestconst and char constants
Fix wrapping D constants using %dmanifestconst
Php fix for enum value of '\0'
Fix static const char member variables wrappers with %javaconst(1).
Expand char testing in enums and %constant
Java char changes file update
Java enum and static member variable escaping fix for chars
Add tests for enum values and static const member variables chars containing escape sequences
Minor documentation tweak
Conflicts:
CHANGES.current
The functions Swig_typemap_new_scope() and Swig_typemap_pop_scope() introduced
by 503746e964 back in 2000 were never used and
ended up being commented out themselves, but support for typemap scopes still
remain in several other functions. Remove it completely to make the code
simpler without any ill effects.
Fix for breakages in previous few commits:
- Perl test-suite - the "varout" typemap "type" attribute is now
expanded in typemap.c instead of Perl.cxx.
- The swig_typemap_warn errors testcase showed that $1 was no longer
being expanded correctly when used in output typemaps (lname not set).
Test case is slightly modified from the test case in issue #250
Use of constant objects does not seem to work in Python - the type is
SwigPyObject instead of constant_directive.Type1.
This is just a simple code refactor, moving and function renaming to
remove the %extend code out of the parser into its own file now
that it isn't just used in the parser.
Fixes problem with method overloading when some methods are added by %extend
and others are real methods and using template default parameters with smart pointers.
This is noticeable as a regression since 2.0.12 when using the default smart pointer
handling for some languages when the smart pointer wraps std::map and other STL containers.
Fixes SF Bug 1363
fixed language symbol table nested classes name separator, test added
fixed %feature "flatnested" working with %extend
fixed Swig_offset_string for empty string
added simple template to save/restore values in current scope (readability reasons)
* nested:
Deprecation of the 'nestedworkaround' feature
Ensure -c++out is not used with -c++
Add missing header to new source file
Nested C class setters restored in c++out mode for Octave
Classprefix fixed after private nested classes some comments and spaces added
Fix template partial specialization detection
Minor tweaks in Swig_feature_set
Swig_offset_string moved to misc.c
nested private classes are discarded while parsing nested relate functions are moved to nested.cxx and renamed accordingly
out-of-scope template definitions fixed nested_private test disabled again
fixed out-of-scope nested class definitions, added a test enabled nested C structs assignment (still disabled for Octave), added Java runtime test fixed nested_private test case for Java & C#
Testcase of private nested class usage causing segfault
C nested struct passed by value example
Add in Travis testing for nested branch
Add C++ nested class example
Minor code improvements
Cosmetics/code beautification of nested class support
Nested classes support
Error checking for this combination implemented as well as correcting
Octave
Also refactor, replacing CPlusPlusOut variable with cparse_cplusplusout
for an implementation which more closely resembles cparse_cplusplus which
is also required in both .c and .cxx files.
Suitable casts are required so that assignment of instances of nested classes
work as the nested class is duplicated in the global namespace, eg:
struct Outer {
struct Nested {
int bar;
} bar_instance;
};
Outer.bar_instance can now be assigned to.
Closes#89
Squash merge branch 'master' of https://github.com/wkalinin/swig into wkalinin-nested
By Vladimir Kalinin
* 'master' of https://github.com/wkalinin/swig:
CPlusPlusOut mode for Octave
nested class illustration
fixed "Abstract" flag for nested classes added an example enabled anonymous nested structs runtime test
porting
warnings disabled
porting fixes
java runtime tests ported
nested class closing bracket offset fixed
removed double nested template (not supported by %template parsing)
template_nested test extended
parent field made public
property access fixed
replaced tabs with spaces
warning W-reorder
deprecated warnings removed, derived_nested runtime test added
optimized string indenting
Nested classes indenting
nested classes docs
fixed the order in which flattened inner classes are added after the outer
Private nested classes were getting into the type table.
Java getProxyName() fix for nested classes fixes the case when nested classes is forward declared
Fix for a case when a nested class inherits from the same base as the outer. (Base class constructor declaration is found first in this case)
merge fix
nested C struct first immediate declaration incorrectly renamed sample fixed
tests updated to reflect nested classes support
Java nested classes support (1)
flattening should remove the link to the outer class
access mode correctly set/restored for nested classes
nested templates should be skipped while flattening (template nodes themselves, not expanded versions) also non-public nested classes should be ignored
If nested classes are not supported, default behaviour is flattening, not ignoring flag "nested" is preserved, so, the nested classes can be ignored by user
nested workaround test updated
template instantiated within a class is marked as nested for ignoring purposes
%ignore not applied to the nested classed, because "nested" flag is set too late
typedef name takes precedence over the real name (reason?)
unnamed structs should be processed for all the languages
nested C struct instances are wrapped as "immutable"
tree building
typedef declaration for unnamed C structures fixed
nested classes "flattening"
fixed %ignoring nested classes
renamed "nested" attribute to "nested:outer" added "nested" flag, to be used with $ignore (it is not removed while flattening) added nestedClassesSupported() function to the Language interface
renamed "nested" attribute to "nested:outer" added "nested" flag, to be used with $ignore (it is not removed while flattening) added nestedClassesSupported() function to the Language interface
tree iteration fix
dirclassname variable names unified memory issue fixed
merge error
ignore unnamed structs for C++
unnamed nested C structs naming & unnesting
class added to classes hash under typedef name
private nested classes skipped
test updated due to nested templates support
anonymous structs with inheritance fixed nested_class test to allow anonymous structs w/o declarator
tests updated: nested workaround removed from namespace_class.i propagated nested template declaration to the C++ file
injected members scope
nested tempplates fixes, nested structures in "C" mode parsing added utility function "appendSibling" (like "appendChild")
nested unnamed structures parsing fixes, access mode restored on nested class end, tdname is properly patched with outer class name prefix
memory management fixes
nested templates (1)
Nested unnamed structs
Nested class support (1)
Nested class support (1)
