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

Add improved namespace support - the nspace feature, working for Java only at the moment.

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@11896 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
William S Fulton 2010-03-04 21:27:23 +00:00
commit 1253657bb4
23 changed files with 645 additions and 266 deletions
Download patch file Download diff file Expand all files Collapse all files

30
CHANGES.current
View file

@ -1,6 +1,34 @@
Version 1.3.41 (in progress)
Version 2.0.0 (in progress)
============================
2010-03-04: wsfulton
Added the nspace feature. This adds some improved namespace support. Currently only Java
is supported for target languages, where C++ namespaces are automatically translated into
Java packages. The feature only applies to classes,struct,unions and enums declared within
a namespace. Methods and variables declared in namespaces still effectively have their
namespaces flattened. Example usage:
%feature(nspace) Outer::Inner1::Color;
%feature(nspace) Outer::Inner2::Color;
namespace Outer {
namespace Inner1 {
struct Color {
...
};
}
namespace Inner2 {
struct Color {
...
};
}
}
For Java, the -package option is also required when using the nspace feature. Say
we use -package com.myco, the two classes can then be accessed as follows from Java:
com.myco.Outer.Inner1.Color and com.myco.Outer.Inner2.Color.
2010-02-27: wsfulton
[Python] Remove -dirvtable from the optimizations included by -O as it this option
currently leads to memory leaks as reported by Johan Blake.

1
Examples/test-suite/common.mk
View file

@ -242,6 +242,7 @@ CPP_TEST_CASES += \
namespace_typemap \
namespace_union \
namespace_virtual_method \
nspace \
naturalvar \
nested_class \
nested_comment \

23
Examples/test-suite/java/Makefile.in
View file

@ -37,26 +37,27 @@ CPP_TEST_CASES = \
include $(srcdir)/../common.mk
# Overridden variables here
SWIGOPT += -package $*
JAVA_PACKAGE = $*
SWIGOPT += -package $(JAVA_PACKAGE)
INTERFACEDIR = ../../
# Custom tests - tests with additional commandline options
# none!
nspace.%: JAVA_PACKAGE = $*Package
# Rules for the different types of tests
%.cpptest:
$(setup)
+(cd $* && $(swig_and_compile_cpp))
+(cd $(JAVA_PACKAGE) && $(swig_and_compile_cpp))
$(run_testcase)
%.ctest:
$(setup)
+(cd $* && $(swig_and_compile_c))
+(cd $(JAVA_PACKAGE) && $(swig_and_compile_c))
$(run_testcase)
%.multicpptest:
$(setup)
+(cd $* && $(swig_and_compile_multi_cpp))
+(cd $(JAVA_PACKAGE) && $(swig_and_compile_multi_cpp))
$(run_testcase)
# Makes a directory for the testcase if it does not exist
@ -66,24 +67,24 @@ setup = \
else \
echo "$(ACTION)ing testcase $* under $(LANGUAGE)" ; \
fi; \
if [ ! -d $* ]; then \
mkdir $*; \
if [ ! -d $(JAVA_PACKAGE) ]; then \
mkdir $(JAVA_PACKAGE); \
fi
# Compiles java files then runs the testcase. A testcase is only run if
# a file is found which has _runme.java appended after the testcase name.
# Note Java uses LD_LIBRARY_PATH under Unix, PATH under Cygwin/Windows, SHLIB_PATH on HPUX and DYLD_LIBRARY_PATH on Mac OS X.
run_testcase = \
cd $* && $(COMPILETOOL) $(JAVAC) -classpath . *.java && cd .. && \
cd $(JAVA_PACKAGE) && $(COMPILETOOL) $(JAVAC) -classpath . `find . -name "*.java"` && cd .. && \
if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
$(COMPILETOOL) $(JAVAC) -classpath . -d . $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
env LD_LIBRARY_PATH="$*:$$LD_LIBRARY_PATH" PATH="$*:$$PATH" SHLIB_PATH="$*:$$SHLIB_PATH" DYLD_LIBRARY_PATH="$*:$$DYLD_LIBRARY_PATH" $(RUNTOOL) $(JAVA) -classpath . $*_runme; \
env LD_LIBRARY_PATH="$(JAVA_PACKAGE):$$LD_LIBRARY_PATH" PATH="$(JAVA_PACKAGE):$$PATH" SHLIB_PATH="$(JAVA_PACKAGE):$$SHLIB_PATH" DYLD_LIBRARY_PATH="$(JAVA_PACKAGE):$$DYLD_LIBRARY_PATH" $(RUNTOOL) $(JAVA) -classpath . $*_runme; \
fi
# Clean: remove testcase directories
%.clean:
@if [ -d $* ]; then \
rm -rf $*; \
@if [ -d $(JAVA_PACKAGE) ]; then \
rm -rf $(JAVA_PACKAGE); \
fi
clean:

93
Examples/test-suite/nspace.i Normal file
View file

@ -0,0 +1,93 @@
// Test the nspace feature
%module nspace
#if defined(SWIGJAVA)
SWIG_JAVABODY_METHODS(public, public, SWIGTYPE)
%pragma(java) jniclassclassmodifiers = "public class"
%feature("nspace");
%feature("nspace", "0") Outer::Inner2::NoNSpacePlease;
%copyctor;
%ignore Outer::Inner2::Color::Color();
%inline %{
namespace Outer {
class nspace {
};
namespace Inner1 {
enum Channel {
Diffuse,
Specular = 0x10,
Transmission1
};
struct Color {
static Color* create() { return new Color(); }
enum Channel {
Diffuse,
Specular = 0x20,
Transmission
};
int instanceMemberVariable;
static int staticMemberVariable;
void colorInstanceMethod(double d) {}
static void colorStaticMethod(double d) {}
}; // Color
int Color::staticMemberVariable = 0;
Color namespaceFunction(Color k) { return k; }
int namespaceVar = 0;
} // Inner1
namespace Inner2 {
enum Channel {
Diffuse,
Specular /* = 0x30*/,
Transmission2
};
struct Color {
Color() : instanceMemberVariable(0) {}
static Color* create() { return new Color(); }
enum Channel {
Diffuse,
Specular/* = 0x40*/,
Transmission
};
int instanceMemberVariable;
static int staticMemberVariable;
void colorInstanceMethod(double d) {}
static void colorStaticMethod(double d) {}
}; // Color
int Color::staticMemberVariable = 0;
class NoNSpacePlease {};
} // Inner2
class SomeClass {
public:
Inner1::Color::Channel GetInner1ColorChannel() { return Inner1::Color::Transmission; }
Inner2::Color::Channel GetInner2ColorChannel() { return Inner2::Color::Transmission; }
Inner1::Channel GetInner1Channel() { return Inner1::Transmission1; }
Inner2::Channel GetInner2Channel() { return Inner2::Transmission2; }
}; // SomeClass
} // Outer
namespace Outer {
struct MyWorldPart2 {};
}
struct GlobalClass {
void gmethod() {}
};
void test_classes(Outer::SomeClass c, Outer::Inner2::Color cc) {}
%}
#endif

6
Source/Modules/chicken.cxx
View file

@ -1152,9 +1152,9 @@ int CHICKEN::membervariableHandler(Node *n) {
//String *getfunc = NewStringf("%s-%s-get", short_class_name, proc);
//String *setfunc = NewStringf("%s-%s-set", short_class_name, proc);
String *getfunc = Swig_name_get(Swig_name_member(c_class_name, iname));
String *getfunc = Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, c_class_name, iname));
Replaceall(getfunc, "_", "-");
String *setfunc = Swig_name_set(Swig_name_member(c_class_name, iname));
String *setfunc = Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, c_class_name, iname));
Replaceall(setfunc, "_", "-");
Printv(clos_class_defines, " (list '", proc, " ':swig-virtual ':swig-get ", chickenPrimitiveName(getfunc), NIL);
@ -1201,7 +1201,7 @@ int CHICKEN::constructorHandler(Node *n) {
has_constructor_args = 1;
String *iname = Getattr(n, "sym:name");
constructor_name = Swig_name_construct(iname);
constructor_name = Swig_name_construct(NSPACE_TODO, iname);
Replaceall(constructor_name, "_", "-");
return SWIG_OK;
}

30
Source/Modules/csharp.cxx
View file

@ -162,7 +162,7 @@ public:
/* -----------------------------------------------------------------------------
* getProxyName()
*
* Test to see if a type corresponds to something wrapped with a proxy class
* Test to see if a type corresponds to something wrapped with a proxy class.
* Return NULL if not otherwise the proxy class name
* ----------------------------------------------------------------------------- */
@ -1033,7 +1033,7 @@ public:
*/
if (proxy_flag && wrapping_member_flag && !enum_constant_flag) {
// Capitalize the first letter in the variable in the getter/setter function name
bool getter_flag = Cmp(symname, Swig_name_set(Swig_name_member(proxy_class_name, variable_name))) != 0;
bool getter_flag = Cmp(symname, Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, proxy_class_name, variable_name))) != 0;
String *getter_setter_name = NewString("");
if (!getter_flag)
@ -1381,13 +1381,13 @@ public:
if (classname_substituted_flag) {
if (SwigType_isenum(t)) {
// This handles wrapping of inline initialised const enum static member variables (not when wrapping enum items - ignored later on)
Printf(constants_code, "(%s)%s.%s();\n", return_type, imclass_name, Swig_name_get(symname));
Printf(constants_code, "(%s)%s.%s();\n", return_type, imclass_name, Swig_name_get(NSPACE_TODO, symname));
} else {
// This handles function pointers using the %constant directive
Printf(constants_code, "new %s(%s.%s(), false);\n", return_type, imclass_name, Swig_name_get(symname));
Printf(constants_code, "new %s(%s.%s(), false);\n", return_type, imclass_name, Swig_name_get(NSPACE_TODO, symname));
}
} else
Printf(constants_code, "%s.%s();\n", imclass_name, Swig_name_get(symname));
Printf(constants_code, "%s.%s();\n", imclass_name, Swig_name_get(NSPACE_TODO, symname));
// Each constant and enum value is wrapped with a separate PInvoke function call
SetFlag(n, "feature:immutable");
@ -1862,7 +1862,7 @@ public:
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
String *intermediary_function_name = Swig_name_member(proxy_class_name, overloaded_name);
String *intermediary_function_name = Swig_name_member(NSPACE_TODO, proxy_class_name, overloaded_name);
Setattr(n, "proxyfuncname", Getattr(n, "sym:name"));
Setattr(n, "imfuncname", intermediary_function_name);
proxyClassFunctionHandler(n);
@ -1882,7 +1882,7 @@ public:
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
String *intermediary_function_name = Swig_name_member(proxy_class_name, overloaded_name);
String *intermediary_function_name = Swig_name_member(NSPACE_TODO, proxy_class_name, overloaded_name);
Setattr(n, "proxyfuncname", Getattr(n, "sym:name"));
Setattr(n, "imfuncname", intermediary_function_name);
proxyClassFunctionHandler(n);
@ -1962,7 +1962,7 @@ public:
if (wrapping_member_flag && !enum_constant_flag) {
// Properties
setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(Swig_name_member(proxy_class_name, variable_name))) == 0);
setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, proxy_class_name, variable_name))) == 0);
if (setter_flag)
Swig_typemap_attach_parms("csvarin", l, NULL);
}
@ -2132,7 +2132,7 @@ public:
Node *explicit_n = Getattr(n, "explicitcallnode");
if (explicit_n) {
String *ex_overloaded_name = getOverloadedName(explicit_n);
String *ex_intermediary_function_name = Swig_name_member(proxy_class_name, ex_overloaded_name);
String *ex_intermediary_function_name = Swig_name_member(NSPACE_TODO, proxy_class_name, ex_overloaded_name);
String *ex_imcall = Copy(imcall);
Replaceall(ex_imcall, "$imfuncname", ex_intermediary_function_name);
@ -2250,7 +2250,7 @@ public:
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
String *mangled_overname = Swig_name_construct(overloaded_name);
String *mangled_overname = Swig_name_construct(NSPACE_TODO, overloaded_name);
String *imcall = NewString("");
const String *csattributes = Getattr(n, "feature:cs:attributes");
@ -2451,7 +2451,7 @@ public:
String *symname = Getattr(n, "sym:name");
if (proxy_flag) {
Printv(destructor_call, imclass_name, ".", Swig_name_destroy(symname), "(swigCPtr)", NIL);
Printv(destructor_call, imclass_name, ".", Swig_name_destroy(NSPACE_TODO, symname), "(swigCPtr)", NIL);
}
return SWIG_OK;
}
@ -2577,7 +2577,7 @@ public:
if (proxy_flag && global_variable_flag) {
// Capitalize the first letter in the variable to create the getter/setter function name
func_name = NewString("");
setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(variable_name)) == 0);
setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(NSPACE_TODO, variable_name)) == 0);
if (setter_flag)
Printf(func_name, "set");
else
@ -2848,10 +2848,10 @@ public:
// Strange hack to change the name
Setattr(n, "name", Getattr(n, "value")); /* for wrapping of enums in a namespace when emit_action is used */
constantWrapper(n);
value = NewStringf("%s.%s()", imclass_name, Swig_name_get(symname));
value = NewStringf("%s.%s()", imclass_name, Swig_name_get(NSPACE_TODO, symname));
} else {
memberconstantHandler(n);
value = NewStringf("%s.%s()", imclass_name, Swig_name_get(Swig_name_member(proxy_class_name, symname)));
value = NewStringf("%s.%s()", imclass_name, Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, proxy_class_name, symname)));
}
}
}
@ -3279,7 +3279,7 @@ public:
// we're consistent with the sym:overload name in functionWrapper. (?? when
// does the overloaded method name get set?)
imclass_dmethod = NewStringf("SwigDirector_%s", Swig_name_member(classname, overloaded_name));
imclass_dmethod = NewStringf("SwigDirector_%s", Swig_name_member(NSPACE_TODO, classname, overloaded_name));
if (returntype) {

275
Source/Modules/java.cxx
View file

@ -56,7 +56,9 @@ class JAVA:public Language {
String *proxy_class_def;
String *proxy_class_code;
String *module_class_code;
String *proxy_class_name;
String *proxy_class_name; // proxy class name
String *full_proxy_class_name;// fully qualified proxy class name when using nspace feature, otherwise same as proxy_class_name
String *full_imclass_name; // fully qualified intermediary class name when using nspace feature, otherwise same as imclass_name
String *variable_name; //Name of a variable being wrapped
String *proxy_class_constants_code;
String *module_class_constants_code;
@ -125,6 +127,8 @@ public:
proxy_class_code(NULL),
module_class_code(NULL),
proxy_class_name(NULL),
full_proxy_class_name(NULL),
full_imclass_name(NULL),
variable_name(NULL),
proxy_class_constants_code(NULL),
module_class_constants_code(NULL),
@ -157,19 +161,35 @@ public:
/* -----------------------------------------------------------------------------
* getProxyName()
*
* Test to see if a type corresponds to something wrapped with a proxy class
* Return NULL if not otherwise the proxy class name
* Test to see if a type corresponds to something wrapped with a proxy class.
* Return NULL if not otherwise the proxy class name, fully qualified with
* package name if the nspace feature is used.
* ----------------------------------------------------------------------------- */
String *getProxyName(SwigType *t) {
if (proxy_flag) {
Node *n = classLookup(t);
if (n) {
return Getattr(n, "sym:name");
}
}
return NULL;
}
String *proxyname = NULL;
if (proxy_flag) {
Node *n = classLookup(t);
if (n) {
proxyname = Getattr(n, "proxyname");
if (!proxyname) {
String *nspace = Getattr(n, "sym:nspace");
String *symname = Getattr(n, "sym:name");
if (nspace) {
if (Len(package) > 0)
proxyname = NewStringf("%s.%s.%s", package, nspace, symname);
else
proxyname = NewStringf("%s.%s", nspace, symname);
} else {
proxyname = Copy(symname);
}
Setattr(n, "proxyname", proxyname);
Delete(proxyname);
}
}
}
return proxyname;
}
/* -----------------------------------------------------------------------------
* makeValidJniName()
@ -410,7 +430,7 @@ public:
Replaceall(package_path, ".", "/");
}
String *jniname = makeValidJniName(imclass_name);
Printf(wrapper_name, "Java_%s%s_%%f", Char(jnipackage), jniname);
Printf(wrapper_name, "Java_%s%s_%%f", jnipackage, jniname);
Delete(jniname);
Swig_name_register("wrapper", Char(wrapper_name));
@ -1099,7 +1119,7 @@ public:
*/
if (proxy_flag && wrapping_member_flag && !enum_constant_flag) {
// Capitalize the first letter in the variable to create a JavaBean type getter/setter function name
bool getter_flag = Cmp(symname, Swig_name_set(Swig_name_member(proxy_class_name, variable_name))) != 0;
bool getter_flag = Cmp(symname, Swig_name_set(getNSpace(), Swig_name_member(0, proxy_class_name, variable_name))) != 0;
String *getter_setter_name = NewString("");
if (!getter_flag)
@ -1167,6 +1187,24 @@ public:
if (getCurrentClass() && (cplus_mode != PUBLIC))
return SWIG_NOWRAP;
if (proxy_flag && !is_wrapping_class()) {
// Global enums / enums in a namespace
String *nspace = Getattr(n, "sym:nspace");
assert(!full_imclass_name);
if (!nspace) {
full_imclass_name = NewStringf("%s", imclass_name);
} else {
if (Len(package) > 0) {
full_imclass_name = NewStringf("%s.%s", package, imclass_name);
} else {
full_imclass_name = NewStringf("%s", imclass_name);
Printf(stderr, "The nspace feature used on %s is not supported unless a package is specified with -package - Java does not support types declared in the unnamed package accessing types declared in a package.\n", Getattr(n, "name"));
SWIG_exit(EXIT_FAILURE);
}
}
}
enum_code = NewString("");
String *symname = Getattr(n, "sym:name");
String *constants_code = (proxy_flag && is_wrapping_class())? proxy_class_constants_code : module_class_constants_code;
@ -1224,7 +1262,9 @@ public:
Printv(proxy_class_constants_code, " ", enum_code, "\n\n", NIL);
} else {
// Global enums are defined in their own file
String *filen = NewStringf("%s%s.java", SWIG_output_directory(), symname);
String *nspace = Getattr(n, "sym:nspace");
String *output_directory = outputDirectory(nspace);
String *filen = NewStringf("%s%s.java", output_directory, symname);
File *f_enum = NewFile(filen, "w", SWIG_output_files());
if (!f_enum) {
FileErrorDisplay(filen);
@ -1237,14 +1277,21 @@ public:
// Start writing out the enum file
emitBanner(f_enum);
if (Len(package) > 0)
Printf(f_enum, "package %s;\n", package);
if (Len(package) > 0 || nspace) {
Printf(f_enum, "package ");
if (Len(package) > 0)
Printv(f_enum, package, nspace ? "." : "", NIL);
if (nspace)
Printv(f_enum, nspace, NIL);
Printf(f_enum, ";\n");
}
Printv(f_enum, typemapLookup(n, "javaimports", typemap_lookup_type, WARN_NONE), // Import statements
"\n", enum_code, "\n", NIL);
Printf(f_enum, "\n");
Close(f_enum);
Delete(output_directory);
}
} else {
// Wrap C++ enum with simple constant
@ -1257,6 +1304,11 @@ public:
Delete(enum_code);
enum_code = NULL;
if (proxy_flag && !is_wrapping_class()) {
Delete(full_imclass_name);
full_imclass_name = 0;
}
}
return SWIG_OK;
}
@ -1418,13 +1470,13 @@ public:
if (classname_substituted_flag) {
if (SwigType_isenum(t)) {
// This handles wrapping of inline initialised const enum static member variables (not when wrapping enum items - ignored later on)
Printf(constants_code, "%s.swigToEnum(%s.%s());\n", return_type, imclass_name, Swig_name_get(symname));
Printf(constants_code, "%s.swigToEnum(%s.%s());\n", return_type, imclass_name, Swig_name_get(getNSpace(), symname));
} else {
// This handles function pointers using the %constant directive
Printf(constants_code, "new %s(%s.%s(), false);\n", return_type, imclass_name, Swig_name_get(symname));
Printf(constants_code, "new %s(%s.%s(), false);\n", return_type, imclass_name, Swig_name_get(getNSpace(), symname));
}
} else
Printf(constants_code, "%s.%s();\n", imclass_name, Swig_name_get(symname));
Printf(constants_code, "%s.%s();\n", imclass_name, Swig_name_get(getNSpace(), symname));
// Each constant and enum value is wrapped with a separate JNI function call
SetFlag(n, "feature:immutable");
@ -1691,16 +1743,18 @@ public:
/* Also insert the swigTakeOwnership and swigReleaseOwnership methods */
if (feature_director) {
String *destruct_jnicall, *release_jnicall, *take_jnicall;
String *changeown_method_name = Swig_name_member(getNSpace(), proxy_class_name, "change_ownership");
destruct_jnicall = NewStringf("%s()", destruct_methodname);
release_jnicall = NewStringf("%s.%s_change_ownership(this, swigCPtr, false)", imclass_name, proxy_class_name);
take_jnicall = NewStringf("%s.%s_change_ownership(this, swigCPtr, true)", imclass_name, proxy_class_name);
release_jnicall = NewStringf("%s.%s(this, swigCPtr, false)", full_imclass_name, changeown_method_name);
take_jnicall = NewStringf("%s.%s(this, swigCPtr, true)", full_imclass_name, changeown_method_name);
emitCodeTypemap(n, false, typemap_lookup_type, "directordisconnect", "methodname", destruct_jnicall);
emitCodeTypemap(n, false, typemap_lookup_type, "directorowner_release", "methodname", release_jnicall);
emitCodeTypemap(n, false, typemap_lookup_type, "directorowner_take", "methodname", take_jnicall);
Delete(destruct_jnicall);
Delete(changeown_method_name);
Delete(release_jnicall);
Delete(take_jnicall);
}
@ -1719,14 +1773,14 @@ public:
Replaceall(proxy_class_def, "$module", module_class_name);
Replaceall(proxy_class_code, "$module", module_class_name);
Replaceall(proxy_class_def, "$imclassname", imclass_name);
Replaceall(proxy_class_code, "$imclassname", imclass_name);
Replaceall(proxy_class_def, "$imclassname", full_imclass_name);
Replaceall(proxy_class_code, "$imclassname", full_imclass_name);
// Add code to do C++ casting to base class (only for classes in an inheritance hierarchy)
if (derived) {
Printv(imclass_cppcasts_code, " public final static native long SWIG$javaclassnameUpcast(long jarg1);\n", NIL);
Replaceall(imclass_cppcasts_code, "$javaclassname", proxy_class_name);
Replaceall(imclass_cppcasts_code, "$javaclassname", full_proxy_class_name);
Printv(upcasts_code,
"SWIGEXPORT jlong JNICALL Java_$jnipackage$imimclass_SWIG$imclazznameUpcast",
@ -1735,7 +1789,7 @@ public:
" (void)jenv;\n" " (void)jcls;\n" " *($cbaseclass **)&baseptr = *($cclass **)&jarg1;\n" " return baseptr;\n" "}\n", "\n", NIL);
String *imimclass = makeValidJniName(imclass_name);
String *imclazzname = makeValidJniName(proxy_class_name);
String *imclazzname = makeValidJniName(full_proxy_class_name);
Replaceall(upcasts_code, "$cbaseclass", c_baseclass);
Replaceall(upcasts_code, "$imclazzname", imclazzname);
Replaceall(upcasts_code, "$cclass", c_classname);
@ -1757,21 +1811,37 @@ public:
File *f_proxy = NULL;
if (proxy_flag) {
proxy_class_name = NewString(Getattr(n, "sym:name"));
String *nspace = getNSpace();
if (!addSymbol(proxy_class_name, n))
if (!nspace) {
full_proxy_class_name = NewStringf("%s", proxy_class_name);
full_imclass_name = NewStringf("%s", imclass_name);
if (Cmp(proxy_class_name, imclass_name) == 0) {
Printf(stderr, "Class name cannot be equal to intermediary class name: %s\n", proxy_class_name);
SWIG_exit(EXIT_FAILURE);
}
if (Cmp(proxy_class_name, module_class_name) == 0) {
Printf(stderr, "Class name cannot be equal to module class name: %s\n", proxy_class_name);
SWIG_exit(EXIT_FAILURE);
}
} else {
if (Len(package) > 0) {
full_proxy_class_name = NewStringf("%s.%s.%s", package, nspace, proxy_class_name);
full_imclass_name = NewStringf("%s.%s", package, imclass_name);
} else {
full_proxy_class_name = NewStringf("%s.%s", nspace, proxy_class_name);
full_imclass_name = NewStringf("%s", imclass_name);
Printf(stderr, "The nspace feature used on %s is not supported unless a package is specified with -package - Java does not support types declared in the unnamed package accessing types declared in a package.\n", Getattr(n, "name"));
SWIG_exit(EXIT_FAILURE);
}
}
if (!addSymbol(proxy_class_name, n, nspace))
return SWIG_ERROR;
if (Cmp(proxy_class_name, imclass_name) == 0) {
Printf(stderr, "Class name cannot be equal to intermediary class name: %s\n", proxy_class_name);
SWIG_exit(EXIT_FAILURE);
}
if (Cmp(proxy_class_name, module_class_name) == 0) {
Printf(stderr, "Class name cannot be equal to module class name: %s\n", proxy_class_name);
SWIG_exit(EXIT_FAILURE);
}
String *filen = NewStringf("%s%s.java", SWIG_output_directory(), proxy_class_name);
String *output_directory = outputDirectory(nspace);
String *filen = NewStringf("%s%s.java", output_directory, proxy_class_name);
f_proxy = NewFile(filen, "w", SWIG_output_files());
if (!f_proxy) {
FileErrorDisplay(filen);
@ -1784,8 +1854,14 @@ public:
// Start writing out the proxy class file
emitBanner(f_proxy);
if (Len(package) > 0)
Printf(f_proxy, "package %s;\n", package);
if (Len(package) > 0 || nspace) {
Printf(f_proxy, "package ");
if (Len(package) > 0)
Printv(f_proxy, package, nspace ? "." : "", NIL);
if (nspace)
Printv(f_proxy, nspace, NIL);
Printf(f_proxy, ";\n");
}
Clear(proxy_class_def);
Clear(proxy_class_code);
@ -1793,6 +1869,7 @@ public:
destructor_call = NewString("");
destructor_throws_clause = NewString("");
proxy_class_constants_code = NewString("");
Delete(output_directory);
}
Language::classHandler(n);
@ -1804,9 +1881,9 @@ public:
Replaceall(proxy_class_def, "$module", module_class_name);
Replaceall(proxy_class_code, "$module", module_class_name);
Replaceall(proxy_class_constants_code, "$module", module_class_name);
Replaceall(proxy_class_def, "$imclassname", imclass_name);
Replaceall(proxy_class_code, "$imclassname", imclass_name);
Replaceall(proxy_class_constants_code, "$imclassname", imclass_name);
Replaceall(proxy_class_def, "$imclassname", full_imclass_name);
Replaceall(proxy_class_code, "$imclassname", full_imclass_name);
Replaceall(proxy_class_constants_code, "$imclassname", full_imclass_name);
Printv(f_proxy, proxy_class_def, proxy_class_code, NIL);
// Write out all the constants
@ -1848,6 +1925,10 @@ public:
Delete(proxy_class_name);
proxy_class_name = NULL;
Delete(full_proxy_class_name);
full_proxy_class_name = NULL;
Delete(full_imclass_name);
full_imclass_name = NULL;
Delete(destructor_call);
destructor_call = NULL;
Delete(destructor_throws_clause);
@ -1869,7 +1950,7 @@ public:
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
String *intermediary_function_name = Swig_name_member(proxy_class_name, overloaded_name);
String *intermediary_function_name = Swig_name_member(getNSpace(), proxy_class_name, overloaded_name);
Setattr(n, "proxyfuncname", Getattr(n, "sym:name"));
Setattr(n, "imfuncname", intermediary_function_name);
proxyClassFunctionHandler(n);
@ -1891,7 +1972,7 @@ public:
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
String *intermediary_function_name = Swig_name_member(proxy_class_name, overloaded_name);
String *intermediary_function_name = Swig_name_member(getNSpace(), proxy_class_name, overloaded_name);
Setattr(n, "proxyfuncname", Getattr(n, "sym:name"));
Setattr(n, "imfuncname", intermediary_function_name);
proxyClassFunctionHandler(n);
@ -1967,7 +2048,7 @@ public:
if (wrapping_member_flag && !enum_constant_flag) {
// For wrapping member variables (Javabean setter)
setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(Swig_name_member(proxy_class_name, variable_name))) == 0);
setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(getNSpace(), Swig_name_member(0, proxy_class_name, variable_name))) == 0);
}
/* Start generating the proxy function */
@ -1978,7 +2059,7 @@ public:
Printf(function_code, "static ");
Printf(function_code, "%s %s(", return_type, proxy_function_name);
Printv(imcall, imclass_name, ".$imfuncname(", NIL);
Printv(imcall, full_imclass_name, ".$imfuncname(", NIL);
if (!static_flag) {
Printf(imcall, "swigCPtr");
@ -2121,7 +2202,7 @@ public:
Node *explicit_n = Getattr(n, "explicitcallnode");
if (explicit_n) {
String *ex_overloaded_name = getOverloadedName(explicit_n);
String *ex_intermediary_function_name = Swig_name_member(proxy_class_name, ex_overloaded_name);
String *ex_intermediary_function_name = Swig_name_member(getNSpace(), proxy_class_name, ex_overloaded_name);
String *ex_imcall = Copy(imcall);
Replaceall(ex_imcall, "$imfuncname", ex_intermediary_function_name);
@ -2183,7 +2264,7 @@ public:
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
String *mangled_overname = Swig_name_construct(overloaded_name);
String *mangled_overname = Swig_name_construct(getNSpace(), overloaded_name);
String *imcall = NewString("");
const String *methodmods = Getattr(n, "feature:java:methodmodifiers");
@ -2195,7 +2276,7 @@ public:
Printf(function_code, " %s %s(", methodmods, proxy_class_name);
Printf(helper_code, " static private %s SwigConstruct%s(", im_return_type, proxy_class_name);
Printv(imcall, imclass_name, ".", mangled_overname, "(", NIL);
Printv(imcall, full_imclass_name, ".", mangled_overname, "(", NIL);
/* Attach the non-standard typemaps to the parameter list */
Swig_typemap_attach_parms("in", l, NULL);
@ -2368,7 +2449,7 @@ public:
String *symname = Getattr(n, "sym:name");
if (proxy_flag) {
Printv(destructor_call, imclass_name, ".", Swig_name_destroy(symname), "(swigCPtr)", NIL);
Printv(destructor_call, full_imclass_name, ".", Swig_name_destroy(getNSpace(), symname), "(swigCPtr)", NIL);
generateThrowsClause(n, destructor_throws_clause);
}
return SWIG_OK;
@ -2476,7 +2557,7 @@ public:
if (proxy_flag && global_variable_flag) {
// Capitalize the first letter in the variable to create a JavaBean type getter/setter function name
func_name = NewString("");
setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(variable_name)) == 0);
setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(getNSpace(), variable_name)) == 0);
if (setter_flag)
Printf(func_name, "set");
else
@ -2681,10 +2762,10 @@ public:
// Strange hack to change the name
Setattr(n, "name", Getattr(n, "value")); /* for wrapping of enums in a namespace when emit_action is used */
constantWrapper(n);
value = NewStringf("%s.%s()", imclass_name, Swig_name_get(symname));
value = NewStringf("%s.%s()", full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), symname));
} else {
memberconstantHandler(n);
value = NewStringf("%s.%s()", imclass_name, Swig_name_get(Swig_name_member(proxy_class_name, symname)));
value = NewStringf("%s.%s()", full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), Swig_name_member(getNSpace(), proxy_class_name, symname)));
}
}
}
@ -2698,28 +2779,44 @@ public:
* ----------------------------------------------------------------------------- */
String *getEnumName(SwigType *t, bool jnidescriptor) {
Node *enum_name = NULL;
Node *enumname = NULL;
Node *n = enumLookup(t);
if (n) {
String *symname = Getattr(n, "sym:name");
if (symname) {
// Add in class scope when referencing enum if not a global enum
String *scopename_prefix = Swig_scopename_prefix(Getattr(n, "name"));
String *proxyname = 0;
if (scopename_prefix) {
proxyname = getProxyName(scopename_prefix);
enumname = Getattr(n, "enumname");
if (!enumname || jnidescriptor) {
String *symname = Getattr(n, "sym:name");
if (symname) {
// Add in class scope when referencing enum if not a global enum
String *scopename_prefix = Swig_scopename_prefix(Getattr(n, "name"));
String *proxyname = 0;
if (scopename_prefix) {
proxyname = getProxyName(scopename_prefix);
}
if (proxyname) {
const char *class_separator = jnidescriptor ? "$" : ".";
enumname = NewStringf("%s%s%s", proxyname, class_separator, symname);
} else {
// global enum or enum in a namespace
String *nspace = Getattr(n, "sym:nspace");
if (nspace) {
if (Len(package) > 0)
enumname = NewStringf("%s.%s.%s", package, nspace, symname);
else
enumname = NewStringf("%s.%s", nspace, symname);
} else {
enumname = Copy(symname);
}
}
if (!jnidescriptor) { // not cached
Setattr(n, "enumname", enumname);
Delete(enumname);
}
Delete(scopename_prefix);
}
if (proxyname) {
const char *class_separator = jnidescriptor ? "$" : ".";
enum_name = NewStringf("%s%s%s", proxyname, class_separator, symname);
} else {
enum_name = NewStringf("%s", symname);
}
Delete(scopename_prefix);
}
}
return enum_name;
return enumname;
}
/* -----------------------------------------------------------------------------
@ -3004,10 +3101,10 @@ public:
if (Cmp(jtype, "long") == 0) {
if (proxy_flag) {
if (!GetFlag(p, "tmap:jtype:nopgcpp") && !nopgcpp_flag) {
Node *n = classLookup(t);
if (n) {
String *proxyname = getProxyName(t);
if (proxyname) {
// Found a struct/class parameter passed by value, reference, pointer, or pointer reference
proxyClassName = Getattr(n, "sym:name");
proxyClassName = proxyname;
} else {
// Look for proxy class parameters passed to C++ layer using non-default typemaps, ie not one of above types
String *jstype = NewString(Getattr(p, "tmap:jstype"));
@ -3045,6 +3142,30 @@ public:
return proxyClassName;
}
/* -----------------------------------------------------------------------------
* outputDirectory()
*
* Return the directory to use for generating Java classes/enums and create the
* subdirectory (does not create if language specific outdir does not exist).
* ----------------------------------------------------------------------------- */
String *outputDirectory(String *nspace) {
String *output_directory = Copy(SWIG_output_directory());
if (nspace) {
String *nspace_subdirectory = Copy(nspace);
Replaceall(nspace_subdirectory, ".", SWIG_FILE_DELIMITER);
String *newdir_error = Swig_new_subdirectory(output_directory, nspace_subdirectory);
if (newdir_error) {
Printf(stderr, "%s\n", newdir_error);
Delete(newdir_error);
SWIG_exit(EXIT_FAILURE);
}
Printv(output_directory, nspace_subdirectory, SWIG_FILE_DELIMITER, 0);
Delete(nspace_subdirectory);
}
return output_directory;
}
/*----------------------------------------------------------------------
* Start of director methods
*--------------------------------------------------------------------*/
@ -3155,13 +3276,13 @@ public:
// Output the director connect method:
String *jni_imclass_name = makeValidJniName(imclass_name);
String *norm_name = SwigType_namestr(Getattr(n, "name"));
String *swig_director_connect = NewStringf("%s_director_connect", proxy_class_name);
String *swig_director_connect = Swig_name_member(getNSpace(), proxy_class_name, "director_connect");
String *swig_director_connect_jni = makeValidJniName(swig_director_connect);
String *sym_name = Getattr(n, "sym:name");
Wrapper *code_wrap;
Printf(imclass_class_code, " public final static native void %s(%s obj, long cptr, boolean mem_own, boolean weak_global);\n",
swig_director_connect, proxy_class_name);
swig_director_connect, full_proxy_class_name);
code_wrap = NewWrapper();
Printf(code_wrap->def,
@ -3183,10 +3304,10 @@ public:
Delete(swig_director_connect);
// Output the swigReleaseOwnership, swigTakeOwnership methods:
String *changeown_method_name = NewStringf("%s_change_ownership", proxy_class_name);
String *changeown_method_name = Swig_name_member(getNSpace(), proxy_class_name, "change_ownership");
String *changeown_jnimethod_name = makeValidJniName(changeown_method_name);
Printf(imclass_class_code, " public final static native void %s(%s obj, long cptr, boolean take_or_release);\n", changeown_method_name, proxy_class_name);
Printf(imclass_class_code, " public final static native void %s(%s obj, long cptr, boolean take_or_release);\n", changeown_method_name, full_proxy_class_name);
code_wrap = NewWrapper();
Printf(code_wrap->def,
@ -3342,7 +3463,7 @@ public:
// we're consistent with the sym:overload name in functionWrapper. (?? when
// does the overloaded method name get set?)
imclass_dmethod = NewStringf("SwigDirector_%s", Swig_name_member(classname, overloaded_name));
imclass_dmethod = NewStringf("SwigDirector_%s", Swig_name_member(getNSpace(), classname, overloaded_name));
if (returntype) {

62
Source/Modules/lang.cxx
View file

@ -60,6 +60,7 @@ extern "C" {
static int InClass = 0; /* Parsing C++ or not */
static String *ClassName = 0; /* This is the real name of the current class */
static String *ClassPrefix = 0; /* Class prefix */
static String *NSpace = 0; /* Namespace for the nspace feature */
static String *ClassType = 0; /* Fully qualified type name to use */
static String *DirectorClassName = 0; /* Director name of the current class */
int Abstract = 0;
@ -1198,7 +1199,7 @@ int Language::memberfunctionHandler(Node *n) {
Setline(cbn, Getline(n));
memberconstantHandler(cbn);
Setattr(n, "feature:callback:name", Swig_name_member(ClassPrefix, cbname));
Setattr(n, "feature:callback:name", Swig_name_member(NSpace, ClassPrefix, cbname));
Delete(cb);
Delete(cbn);
@ -1211,7 +1212,7 @@ int Language::memberfunctionHandler(Node *n) {
}
}
String *fname = Swig_name_member(ClassPrefix, symname);
String *fname = Swig_name_member(NSpace, ClassPrefix, symname);
if (Extend && SmartPointer) {
if (!Getattr(n, "classname")) {
Setattr(n, "classname", Getattr(CurrentClass, "allocate:smartpointerbase"));
@ -1236,7 +1237,7 @@ int Language::memberfunctionHandler(Node *n) {
if (GetFlag(n, "explicitcall"))
DirectorExtraCall = CWRAP_DIRECTOR_ONE_CALL;
Swig_MethodToFunction(n, ClassType, Getattr(n, "template") ? SmartPointer : Extend | SmartPointer | DirectorExtraCall, director_type,
Swig_MethodToFunction(n, NSpace, ClassType, Getattr(n, "template") ? SmartPointer : Extend | SmartPointer | DirectorExtraCall, director_type,
is_member_director(CurrentClass, n));
Setattr(n, "sym:name", fname);
@ -1272,10 +1273,10 @@ int Language::staticmemberfunctionHandler(Node *n) {
cname = NewStringf("%s::%s", sname, name);
} else {
String *mname = Swig_name_mangle(ClassName);
cname = Swig_name_member(mname, name);
cname = Swig_name_member(NSpace, mname, name);
Delete(mname);
}
mrename = Swig_name_member(ClassPrefix, symname);
mrename = Swig_name_member(NSpace, ClassPrefix, symname);
if (Extend) {
String *code = Getattr(n, "code");
@ -1299,7 +1300,7 @@ int Language::staticmemberfunctionHandler(Node *n) {
if (cb) {
String *cbname = NewStringf(cb, symname);
Setattr(n, "feature:callback:name", Swig_name_member(ClassPrefix, cbname));
Setattr(n, "feature:callback:name", Swig_name_member(NSpace, ClassPrefix, cbname));
Setattr(n, "feature:callback:staticname", name);
}
Delattr(n, "storage");
@ -1380,9 +1381,9 @@ int Language::membervariableHandler(Node *n) {
SwigType *type = Getattr(n, "type");
if (!AttributeFunctionGet) {
String *mname = Swig_name_member(ClassPrefix, symname);
String *mrename_get = Swig_name_get(mname);
String *mrename_set = Swig_name_set(mname);
String *mname = Swig_name_member(0, ClassPrefix, symname);
String *mrename_get = Swig_name_get(NSpace, mname);
String *mrename_set = Swig_name_set(NSpace, mname);
Delete(mname);
/* Create a function to set the value of the variable */
@ -1493,7 +1494,7 @@ int Language::membervariableHandler(Node *n) {
cpp_member_func(Char(gname), Char(gname), type, 0);
Delete(ActionFunc);
} else {
String *cname = Swig_name_get(name);
String *cname = Swig_name_get(NSpace, name);
cpp_member_func(Char(cname), Char(gname), type, 0);
Delete(cname);
}
@ -1506,7 +1507,7 @@ int Language::membervariableHandler(Node *n) {
cpp_member_func(Char(gname), Char(gname), vty, p);
Delete(ActionFunc);
} else {
String *cname = Swig_name_set(name);
String *cname = Swig_name_set(NSpace, name);
cpp_member_func(Char(cname), Char(gname), vty, p);
Delete(cname);
}
@ -1534,7 +1535,7 @@ int Language::staticmembervariableHandler(Node *n) {
String *cname, *mrename;
/* Create the variable name */
mrename = Swig_name_member(ClassPrefix, symname);
mrename = Swig_name_member(0, ClassPrefix, symname);
cname = NewStringf("%s::%s", classname, name);
Setattr(n, "sym:name", mrename);
@ -1676,7 +1677,7 @@ int Language::memberconstantHandler(Node *n) {
String *symname = Getattr(n, "sym:name");
String *value = Getattr(n, "value");
String *mrename = Swig_name_member(ClassPrefix, symname);
String *mrename = Swig_name_member(NSpace, ClassPrefix, symname);
Setattr(n, "sym:name", mrename);
String *new_name = 0;
@ -1908,7 +1909,7 @@ int Language::classDirectorDisown(Node *n) {
Node *disown = NewHash();
String *mrename;
String *symname = Getattr(n, "sym:name");
mrename = Swig_name_disown(symname); //Getattr(n, "name"));
mrename = Swig_name_disown(NSpace, symname);
String *type = NewString(ClassType);
String *name = NewString("self");
SwigType_add_pointer(type);
@ -2315,6 +2316,7 @@ int Language::classDeclaration(Node *n) {
String *name = Getattr(n, "name");
String *tdname = Getattr(n, "tdname");
String *symname = Getattr(n, "sym:name");
String *symnspace = Getattr(n, "sym:nspace");
char *classname = tdname ? Char(tdname) : Char(name);
char *iname = Char(symname);
@ -2343,6 +2345,7 @@ int Language::classDeclaration(Node *n) {
ClassName = NewString(classname);
ClassPrefix = NewString(iname);
NSpace = symnspace;
if (strip) {
ClassType = NewString(classname);
} else {
@ -2403,6 +2406,7 @@ int Language::classDeclaration(Node *n) {
Language::classHandler(n);
}
NSpace = 0;
InClass = 0;
CurrentClass = 0;
Delete(ClassType);
@ -2635,7 +2639,7 @@ static String *get_director_ctor_code(Node *n, String *director_ctor_code, Strin
int Language::constructorHandler(Node *n) {
Swig_require("constructorHandler", n, "?name", "*sym:name", "?type", "?parms", NIL);
String *symname = Getattr(n, "sym:name");
String *mrename = Swig_name_construct(symname);
String *mrename = Swig_name_construct(NSpace, symname);
String *nodeType = Getattr(n, "nodeType");
int constructor = (!Cmp(nodeType, "constructor"));
List *abstract = 0;
@ -2647,7 +2651,7 @@ int Language::constructorHandler(Node *n) {
Setattr(n, "handled_as_constructor", "1");
}
Swig_ConstructorToFunction(n, ClassType, none_comparison, director_ctor, CPlusPlus, Getattr(n, "template") ? 0 : Extend);
Swig_ConstructorToFunction(n, NSpace, ClassType, none_comparison, director_ctor, CPlusPlus, Getattr(n, "template") ? 0 : Extend);
Setattr(n, "sym:name", mrename);
functionWrapper(n);
Delete(mrename);
@ -2664,12 +2668,12 @@ int Language::constructorHandler(Node *n) {
int Language::copyconstructorHandler(Node *n) {
Swig_require("copyconstructorHandler", n, "?name", "*sym:name", "?type", "?parms", NIL);
String *symname = Getattr(n, "sym:name");
String *mrename = Swig_name_copyconstructor(symname);
String *mrename = Swig_name_copyconstructor(NSpace, symname);
List *abstract = 0;
String *director_ctor = get_director_ctor_code(n, director_ctor_code,
director_prot_ctor_code,
abstract);
Swig_ConstructorToFunction(n, ClassType, none_comparison, director_ctor, CPlusPlus, Getattr(n, "template") ? 0 : Extend);
Swig_ConstructorToFunction(n, NSpace, ClassType, none_comparison, director_ctor, CPlusPlus, Getattr(n, "template") ? 0 : Extend);
Setattr(n, "sym:name", mrename);
functionWrapper(n);
Delete(mrename);
@ -2739,9 +2743,9 @@ int Language::destructorHandler(Node *n) {
if (csymname && (*csymname == '~'))
csymname += 1;
mrename = Swig_name_destroy(csymname);
mrename = Swig_name_destroy(NSpace, csymname);
Swig_DestructorToFunction(n, ClassType, CPlusPlus, Extend);
Swig_DestructorToFunction(n, NSpace, ClassType, CPlusPlus, Extend);
Setattr(n, "sym:name", mrename);
functionWrapper(n);
Delete(mrename);
@ -2844,7 +2848,7 @@ int Language::variableWrapper(Node *n) {
String *tm = Swig_typemap_lookup("globalin", n, name, 0);
Swig_VarsetToFunction(n, flags);
String *sname = Swig_name_set(symname);
String *sname = Swig_name_set(NSpace, symname);
Setattr(n, "sym:name", sname);
Delete(sname);
@ -2879,7 +2883,7 @@ int Language::variableWrapper(Node *n) {
}
Swig_VargetToFunction(n, flags);
String *gname = Swig_name_get(symname);
String *gname = Swig_name_get(NSpace, symname);
Setattr(n, "sym:name", gname);
Delete(gname);
functionWrapper(n);
@ -2922,11 +2926,11 @@ void Language::main(int argc, char *argv[]) {
* Returns 1 if the symbol is added successfully.
* Prints an error message and returns 0 if a conflict occurs.
* The scope is optional for target languages and if supplied must be a fully
* resolved scope and the symbol s must not contain any scope qualifiers.
* qualified scope and the symbol s must not contain any scope qualifiers.
* ----------------------------------------------------------------------------- */
int Language::addSymbol(const String *s, const Node *n, const_String_or_char_ptr scope) {
Hash *symbols = Getattr(symtabs, scope);
Hash *symbols = Getattr(symtabs, scope ? scope : "");
if (!symbols) {
// New scope which has not been added by the target language - lazily created.
symbols = NewHash();
@ -3306,7 +3310,7 @@ bool Language::extraDirectorProtectedCPPMethodsRequired() const {
* Language::is_wrapping_class()
* ----------------------------------------------------------------------------- */
int Language::is_wrapping_class() {
int Language::is_wrapping_class() const {
return InClass;
}
@ -3318,6 +3322,14 @@ Node *Language::getCurrentClass() const {
return CurrentClass;
}
/* -----------------------------------------------------------------------------
* Language::getNSpace()
* ----------------------------------------------------------------------------- */
String *Language::getNSpace() const {
return NSpace;
}
/* -----------------------------------------------------------------------------
* Language::getClassName()
* ----------------------------------------------------------------------------- */

14
Source/Modules/lua.cxx
View file

@ -758,7 +758,7 @@ public:
current=NO_CPP;
// normally SWIG will generate 2 wrappers, a get and a set
// but in certain scenarios (immutable, or if its arrays), it will not
String *getName = Swig_name_wrapper(Swig_name_get(iname));
String *getName = Swig_name_wrapper(Swig_name_get(NSPACE_TODO, iname));
String *setName = 0;
// checking whether it can be set to or not appears to be a very error prone issue
// I refered to the Language::variableWrapper() to find this out
@ -770,7 +770,7 @@ public:
Delete(tm);
if (assignable) {
setName = Swig_name_wrapper(Swig_name_set(iname));
setName = Swig_name_wrapper(Swig_name_set(NSPACE_TODO, iname));
} else {
// how about calling a 'this is not settable' error message?
setName = NewString("SWIG_Lua_set_immutable"); // error message
@ -790,7 +790,6 @@ public:
// REPORT("constantWrapper", n);
String *name = Getattr(n, "name");
String *iname = Getattr(n, "sym:name");
//String *nsname = !nspace ? Copy(iname) : NewStringf("%s::%s",ns_name,iname);
String *nsname = Copy(iname);
SwigType *type = Getattr(n, "type");
String *rawval = Getattr(n, "rawval");
@ -799,7 +798,6 @@ public:
if (!addSymbol(iname, n))
return SWIG_ERROR;
//if (nspace) Setattr(n,"sym:name",nsname);
/* Special hook for member pointer */
if (SwigType_type(type) == T_MPOINTER) {
@ -997,7 +995,7 @@ public:
Printv(f_wrappers, "static swig_lua_class _wrap_class_", mangled_classname, " = { \"", class_name, "\", &SWIGTYPE", SwigType_manglestr(t), ",", NIL);
if (have_constructor) {
Printf(f_wrappers, "%s", Swig_name_wrapper(Swig_name_construct(constructor_name)));
Printf(f_wrappers, "%s", Swig_name_wrapper(Swig_name_construct(NSPACE_TODO, constructor_name)));
Delete(constructor_name);
constructor_name = 0;
} else {
@ -1043,7 +1041,7 @@ public:
current = NO_CPP;
realname = iname ? iname : name;
rname = Swig_name_wrapper(Swig_name_member(class_name, realname));
rname = Swig_name_wrapper(Swig_name_member(NSPACE_TODO, class_name, realname));
if (!Getattr(n, "sym:nextSibling")) {
Printv(s_methods_tab, tab4, "{\"", realname, "\", ", rname, "}, \n", NIL);
}
@ -1063,9 +1061,9 @@ public:
current = MEMBER_VAR;
Language::membervariableHandler(n);
current = NO_CPP;
gname = Swig_name_wrapper(Swig_name_get(Swig_name_member(class_name, symname)));
gname = Swig_name_wrapper(Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)));
if (!GetFlag(n, "feature:immutable")) {
sname = Swig_name_wrapper(Swig_name_set(Swig_name_member(class_name, symname)));
sname = Swig_name_wrapper(Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)));
} else {
//sname = NewString("0");
sname = NewString("SWIG_Lua_set_immutable"); // error message

10
Source/Modules/modula3.cxx
View file

@ -2620,7 +2620,7 @@ MODULA3():
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
String *intermediary_function_name = Swig_name_member(proxy_class_name, overloaded_name);
String *intermediary_function_name = Swig_name_member(NSPACE_TODO, proxy_class_name, overloaded_name);
Setattr(n, "proxyfuncname", Getattr(n, "sym:name"));
Setattr(n, "imfuncname", intermediary_function_name);
proxyClassFunctionHandler(n);
@ -2641,7 +2641,7 @@ MODULA3():
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
String *intermediary_function_name = Swig_name_member(proxy_class_name, overloaded_name);
String *intermediary_function_name = Swig_name_member(NSPACE_TODO, proxy_class_name, overloaded_name);
Setattr(n, "proxyfuncname", Getattr(n, "sym:name"));
Setattr(n, "imfuncname", intermediary_function_name);
proxyClassFunctionHandler(n);
@ -2699,7 +2699,7 @@ MODULA3():
if (proxy_flag && wrapping_member_flag && !enum_constant_flag) {
// Properties
setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(Swig_name_member(proxy_class_name, variable_name)))
setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, proxy_class_name, variable_name)))
== 0);
}
@ -2844,7 +2844,7 @@ MODULA3():
String *imcall = NewString("");
Printf(proxy_class_code, " %s %s(", Getattr(n, "feature:modula3:methodmodifiers"), proxy_class_name);
Printv(imcall, " : this(", m3raw_name, ".", Swig_name_construct(overloaded_name), "(", NIL);
Printv(imcall, " : this(", m3raw_name, ".", Swig_name_construct(NSPACE_TODO, overloaded_name), "(", NIL);
/* Attach the non-standard typemaps to the parameter list */
Swig_typemap_attach_parms("in", l, NULL);
@ -2935,7 +2935,7 @@ MODULA3():
String *symname = Getattr(n, "sym:name");
if (proxy_flag) {
Printv(destructor_call, m3raw_name, ".", Swig_name_destroy(symname), "(swigCPtr)", NIL);
Printv(destructor_call, m3raw_name, ".", Swig_name_destroy(NSPACE_TODO, symname), "(swigCPtr)", NIL);
}
return SWIG_OK;
}

18
Source/Modules/octave.cxx
View file

@ -701,8 +701,8 @@ public:
Wrapper *getf = NewWrapper();
Wrapper *setf = NewWrapper();
String *getname = Swig_name_get(iname);
String *setname = Swig_name_set(iname);
String *getname = Swig_name_get(NSPACE_TODO, iname);
String *setname = Swig_name_set(NSPACE_TODO, iname);
Printf(setf->def, "static octave_value_list _wrap_%s(const octave_value_list& args,int nargout) {", setname);
Printf(setf->def, "if (!SWIG_check_num_args(\"%s_set\",args.length(),1,1,0)) return octave_value_list();", iname);
@ -882,7 +882,7 @@ public:
Printv(f_wrappers, "static swig_octave_class _wrap_class_", class_name, " = {\"", class_name, "\", &SWIGTYPE", SwigType_manglestr(t), ",", NIL);
Printv(f_wrappers, Swig_directorclass(n) ? "1," : "0,", NIL);
if (have_constructor) {
String *cname = Swig_name_construct(constructor_name);
String *cname = Swig_name_construct(NSPACE_TODO, constructor_name);
String *wcname = Swig_name_wrapper(cname);
String *tname = texinfo_name(n);
Printf(f_wrappers, "%s,%s,", wcname, tname);
@ -915,7 +915,7 @@ public:
String *name = Getattr(n, "name");
String *iname = GetChar(n, "sym:name");
String *realname = iname ? iname : name;
String *rname = Swig_name_wrapper(Swig_name_member(class_name, realname));
String *rname = Swig_name_wrapper(Swig_name_member(NSPACE_TODO, class_name, realname));
if (!Getattr(n, "sym:nextSibling")) {
String *tname = texinfo_name(n);
@ -936,9 +936,9 @@ public:
assert(s_members_tab);
assert(class_name);
String *symname = Getattr(n, "sym:name");
String *getname = Swig_name_wrapper(Swig_name_get(Swig_name_member(class_name, symname)));
String *getname = Swig_name_wrapper(Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)));
String *setname = GetFlag(n, "feature:immutable") ?
NewString("octave_set_immutable") : Swig_name_wrapper(Swig_name_set(Swig_name_member(class_name, symname)));
NewString("octave_set_immutable") : Swig_name_wrapper(Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)));
assert(s_members_tab);
Printf(s_members_tab, "{\"%s\",0,%s,%s,0,0},\n", symname, getname, setname);
@ -988,7 +988,7 @@ public:
String *name = Getattr(n, "name");
String *iname = GetChar(n, "sym:name");
String *realname = iname ? iname : name;
String *rname = Swig_name_wrapper(Swig_name_member(class_name, realname));
String *rname = Swig_name_wrapper(Swig_name_member(NSPACE_TODO, class_name, realname));
if (!Getattr(n, "sym:nextSibling")) {
String *tname = texinfo_name(n);
@ -1014,9 +1014,9 @@ public:
assert(s_members_tab);
assert(class_name);
String *symname = Getattr(n, "sym:name");
String *getname = Swig_name_wrapper(Swig_name_get(Swig_name_member(class_name, symname)));
String *getname = Swig_name_wrapper(Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)));
String *setname = GetFlag(n, "feature:immutable") ?
NewString("octave_set_immutable") : Swig_name_wrapper(Swig_name_set(Swig_name_member(class_name, symname)));
NewString("octave_set_immutable") : Swig_name_wrapper(Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)));
assert(s_members_tab);
Printf(s_members_tab, "{\"%s\",0,%s,%s,1,0},\n", symname, getname, setname);

28
Source/Modules/perl5.cxx
View file

@ -840,8 +840,8 @@ public:
SwigType *t = Getattr(n, "type");
Wrapper *getf, *setf;
String *tm;
String *getname = Swig_name_get(iname);
String *setname = Swig_name_set(iname);
String *getname = Swig_name_get(NSPACE_TODO, iname);
String *setname = Swig_name_set(NSPACE_TODO, iname);
String *get_name = Swig_name_wrapper(getname);
String *set_name = Swig_name_wrapper(setname);
@ -1432,12 +1432,12 @@ public:
if (Getattr(n, "feature:shadow")) {
String *plcode = perlcode(Getattr(n, "feature:shadow"), 0);
String *plaction = NewStringf("%s::%s", cmodule, Swig_name_member(class_name, symname));
String *plaction = NewStringf("%s::%s", cmodule, Swig_name_member(NSPACE_TODO, class_name, symname));
Replaceall(plcode, "$action", plaction);
Delete(plaction);
Printv(pcode, plcode, NIL);
} else {
Printv(pcode, "*", symname, " = *", cmodule, "::", Swig_name_member(class_name, symname), ";\n", NIL);
Printv(pcode, "*", symname, " = *", cmodule, "::", Swig_name_member(NSPACE_TODO, class_name, symname), ";\n", NIL);
}
}
return SWIG_OK;
@ -1462,8 +1462,8 @@ public:
if (blessed) {
Printv(pcode, "*swig_", symname, "_get = *", cmodule, "::", Swig_name_get(Swig_name_member(class_name, symname)), ";\n", NIL);
Printv(pcode, "*swig_", symname, "_set = *", cmodule, "::", Swig_name_set(Swig_name_member(class_name, symname)), ";\n", NIL);
Printv(pcode, "*swig_", symname, "_get = *", cmodule, "::", Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)), ";\n", NIL);
Printv(pcode, "*swig_", symname, "_set = *", cmodule, "::", Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)), ";\n", NIL);
/* Now we need to generate a little Perl code for this */
@ -1501,7 +1501,7 @@ public:
if ((blessed) && (!Getattr(n, "sym:nextSibling"))) {
if (Getattr(n, "feature:shadow")) {
String *plcode = perlcode(Getattr(n, "feature:shadow"), 0);
String *plaction = NewStringf("%s::%s", module, Swig_name_member(class_name, symname));
String *plaction = NewStringf("%s::%s", module, Swig_name_member(NSPACE_TODO, class_name, symname));
Replaceall(plcode, "$action", plaction);
Delete(plaction);
Printv(pcode, plcode, NIL);
@ -1511,12 +1511,12 @@ public:
Printf(pcode, "sub new {\n");
} else {
/* Constructor doesn't match classname so we'll just use the normal name */
Printv(pcode, "sub ", Swig_name_construct(symname), " {\n", NIL);
Printv(pcode, "sub ", Swig_name_construct(NSPACE_TODO, symname), " {\n", NIL);
}
Printv(pcode,
tab4, "my $pkg = shift;\n",
tab4, "my $self = ", cmodule, "::", Swig_name_construct(symname), "(@_);\n", tab4, "bless $self, $pkg if defined($self);\n", "}\n\n", NIL);
tab4, "my $self = ", cmodule, "::", Swig_name_construct(NSPACE_TODO, symname), "(@_);\n", tab4, "bless $self, $pkg if defined($self);\n", "}\n\n", NIL);
have_constructor = 1;
}
@ -1536,7 +1536,7 @@ public:
if (blessed) {
if (Getattr(n, "feature:shadow")) {
String *plcode = perlcode(Getattr(n, "feature:shadow"), 0);
String *plaction = NewStringf("%s::%s", module, Swig_name_member(class_name, symname));
String *plaction = NewStringf("%s::%s", module, Swig_name_member(NSPACE_TODO, class_name, symname));
Replaceall(plcode, "$action", plaction);
Delete(plaction);
Printv(pcode, plcode, NIL);
@ -1548,7 +1548,7 @@ public:
tab4, "return unless defined $self;\n",
tab4, "delete $ITERATORS{$self};\n",
tab4, "if (exists $OWNER{$self}) {\n",
tab8, cmodule, "::", Swig_name_destroy(symname), "($self);\n", tab8, "delete $OWNER{$self};\n", tab4, "}\n}\n\n", NIL);
tab8, cmodule, "::", Swig_name_destroy(NSPACE_TODO, symname), "($self);\n", tab8, "delete $OWNER{$self};\n", tab4, "}\n}\n\n", NIL);
have_destructor = 1;
}
}
@ -1566,7 +1566,7 @@ public:
member_func = 0;
if ((blessed) && (!Getattr(n, "sym:nextSibling"))) {
String *symname = Getattr(n, "sym:name");
Printv(pcode, "*", symname, " = *", cmodule, "::", Swig_name_member(class_name, symname), ";\n", NIL);
Printv(pcode, "*", symname, " = *", cmodule, "::", Swig_name_member(NSPACE_TODO, class_name, symname), ";\n", NIL);
}
return SWIG_OK;
}
@ -1579,7 +1579,7 @@ public:
Language::staticmembervariableHandler(n);
if (blessed) {
String *symname = Getattr(n, "sym:name");
Printv(pcode, "*", symname, " = *", cmodule, "::", Swig_name_member(class_name, symname), ";\n", NIL);
Printv(pcode, "*", symname, " = *", cmodule, "::", Swig_name_member(NSPACE_TODO, class_name, symname), ";\n", NIL);
}
return SWIG_OK;
}
@ -1598,7 +1598,7 @@ public:
blessed = oldblessed;
if (blessed) {
Printv(pcode, "*", symname, " = *", cmodule, "::", Swig_name_member(class_name, symname), ";\n", NIL);
Printv(pcode, "*", symname, " = *", cmodule, "::", Swig_name_member(NSPACE_TODO, class_name, symname), ";\n", NIL);
}
return SWIG_OK;
}

8
Source/Modules/pike.cxx
View file

@ -766,7 +766,7 @@ public:
/* Create a function to set the values of the (mutable) variables */
if (need_setter) {
Wrapper *wrapper = NewWrapper();
String *setter = Swig_name_member(getClassPrefix(), "`->=");
String *setter = Swig_name_member(NSPACE_TODO, getClassPrefix(), "`->=");
String *wname = Swig_name_wrapper(setter);
Printv(wrapper->def, "static void ", wname, "(INT32 args) {", NIL);
Printf(wrapper->locals, "char *name = (char *) STR0(Pike_sp[0-args].u.string);\n");
@ -775,7 +775,7 @@ public:
while (i.item) {
if (!GetFlag(i.item, "feature:immutable")) {
name = Getattr(i.item, "name");
funcname = Swig_name_wrapper(Swig_name_set(Swig_name_member(getClassPrefix(), name)));
funcname = Swig_name_wrapper(Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, getClassPrefix(), name)));
Printf(wrapper->code, "if (!strcmp(name, \"%s\")) {\n", name);
Printf(wrapper->code, "%s(args);\n", funcname);
Printf(wrapper->code, "return;\n");
@ -805,7 +805,7 @@ public:
/* Create a function to get the values of the (mutable) variables */
Wrapper *wrapper = NewWrapper();
String *getter = Swig_name_member(getClassPrefix(), "`->");
String *getter = Swig_name_member(NSPACE_TODO, getClassPrefix(), "`->");
String *wname = Swig_name_wrapper(getter);
Printv(wrapper->def, "static void ", wname, "(INT32 args) {", NIL);
Printf(wrapper->locals, "char *name = (char *) STR0(Pike_sp[0-args].u.string);\n");
@ -813,7 +813,7 @@ public:
i = First(membervariables);
while (i.item) {
name = Getattr(i.item, "name");
funcname = Swig_name_wrapper(Swig_name_get(Swig_name_member(getClassPrefix(), name)));
funcname = Swig_name_wrapper(Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, getClassPrefix(), name)));
Printf(wrapper->code, "if (!strcmp(name, \"%s\")) {\n", name);
Printf(wrapper->code, "%s(args);\n", funcname);
Printf(wrapper->code, "return;\n");

60
Source/Modules/python.cxx
View file

@ -1866,7 +1866,7 @@ public:
&& ((shadow & PYSHADOW_MEMBER))) {
String *nname = Getattr(n, "sym:name");
String *sname = Getattr(getCurrentClass(), "sym:name");
String *cname = Swig_name_construct(sname);
String *cname = Swig_name_construct(NSPACE_TODO, sname);
handled_as_init = (Strcmp(nname, sname) == 0) || (Strcmp(nname, cname) == 0);
Delete(cname);
}
@ -2437,8 +2437,8 @@ public:
}
}
String *getname = Swig_name_get(iname);
String *setname = Swig_name_set(iname);
String *getname = Swig_name_get(NSPACE_TODO, iname);
String *setname = Swig_name_set(NSPACE_TODO, iname);
String *vargetname = NewStringf("Swig_var_%s", getname);
String *varsetname = NewStringf("Swig_var_%s", setname);
@ -2771,7 +2771,7 @@ public:
shadow = oldshadow;
if (shadow) {
String *symname = Getattr(n, "sym:name");
String *mrename = Swig_name_disown(symname); //Getattr(n, "name"));
String *mrename = Swig_name_disown(NSPACE_TODO, symname); //Getattr(n, "name"));
Printv(f_shadow, tab4, "def __disown__(self):\n", NIL);
#ifdef USE_THISOWN
Printv(f_shadow, tab8, "self.thisown = 0\n", NIL);
@ -3029,7 +3029,7 @@ public:
List *shadow_list = Getattr(n, "shadow_methods");
for (int i = 0; i < Len(shadow_list); ++i) {
String *symname = Getitem(shadow_list, i);
Printf(f_shadow_file, "%s.%s = new_instancemethod(%s.%s,None,%s)\n", class_name, symname, module, Swig_name_member(class_name, symname), class_name);
Printf(f_shadow_file, "%s.%s = new_instancemethod(%s.%s,None,%s)\n", class_name, symname, module, Swig_name_member(NSPACE_TODO, class_name, symname), class_name);
}
}
Printf(f_shadow_file, "%s_swigregister = %s.%s_swigregister\n", class_name, module, class_name);
@ -3093,7 +3093,7 @@ public:
}
if (Getattr(n, "feature:shadow")) {
String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4);
String *pyaction = NewStringf("%s.%s", module, Swig_name_member(class_name, symname));
String *pyaction = NewStringf("%s.%s", module, Swig_name_member(NSPACE_TODO, class_name, symname));
Replaceall(pycode, "$action", pyaction);
Delete(pyaction);
Printv(f_shadow, pycode, "\n", NIL);
@ -3105,7 +3105,7 @@ public:
if (!have_addtofunc(n)) {
if (!fastproxy || olddefs) {
Printv(f_shadow, tab4, "def ", symname, "(", parms, ")", returnTypeAnnotation(n), ":", NIL);
Printv(f_shadow, " return ", funcCall(Swig_name_member(class_name, symname), callParms), "\n", NIL);
Printv(f_shadow, " return ", funcCall(Swig_name_member(NSPACE_TODO, class_name, symname), callParms), "\n", NIL);
}
} else {
Printv(f_shadow, tab4, "def ", symname, "(",parms , ")", returnTypeAnnotation(n), ":", NIL);
@ -3118,11 +3118,11 @@ public:
}
if (have_pythonappend(n)) {
fproxy = 0;
Printv(f_shadow, tab8, "val = ", funcCall(Swig_name_member(class_name, symname), callParms), "\n", NIL);
Printv(f_shadow, tab8, "val = ", funcCall(Swig_name_member(NSPACE_TODO, class_name, symname), callParms), "\n", NIL);
Printv(f_shadow, pythoncode(pythonappend(n), tab8), "\n", NIL);
Printv(f_shadow, tab8, "return val\n\n", NIL);
} else {
Printv(f_shadow, tab8, "return ", funcCall(Swig_name_member(class_name, symname), callParms), "\n\n", NIL);
Printv(f_shadow, tab8, "return ", funcCall(Swig_name_member(NSPACE_TODO, class_name, symname), callParms), "\n\n", NIL);
}
}
}
@ -3163,11 +3163,11 @@ public:
if (have_pythonprepend(n))
Printv(f_shadow, pythoncode(pythonprepend(n), tab8), "\n", NIL);
if (have_pythonappend(n)) {
Printv(f_shadow, tab8, "val = ", funcCall(Swig_name_member(class_name, symname), callParms), "\n", NIL);
Printv(f_shadow, tab8, "val = ", funcCall(Swig_name_member(NSPACE_TODO, class_name, symname), callParms), "\n", NIL);
Printv(f_shadow, pythoncode(pythonappend(n), tab8), "\n", NIL);
Printv(f_shadow, tab8, "return val\n\n", NIL);
} else {
Printv(f_shadow, tab8, "return ", funcCall(Swig_name_member(class_name, symname), callParms), "\n\n", NIL);
Printv(f_shadow, tab8, "return ", funcCall(Swig_name_member(NSPACE_TODO, class_name, symname), callParms), "\n\n", NIL);
}
Printv(f_shadow, tab4, modern ? "" : "if _newclass:", symname, " = staticmethod(", symname, ")\n", NIL);
@ -3177,10 +3177,10 @@ public:
} else {
if (!modern) {
Printv(f_shadow, tab4, "__swig_getmethods__[\"", symname, "\"] = lambda x: ", module, ".", Swig_name_member(class_name, symname), "\n", NIL);
Printv(f_shadow, tab4, "__swig_getmethods__[\"", symname, "\"] = lambda x: ", module, ".", Swig_name_member(NSPACE_TODO, class_name, symname), "\n", NIL);
}
if (!classic) {
Printv(f_shadow, tab4, modern ? "" : "if _newclass:", symname, " = staticmethod(", module, ".", Swig_name_member(class_name, symname), ")\n", NIL);
Printv(f_shadow, tab4, modern ? "" : "if _newclass:", symname, " = staticmethod(", module, ".", Swig_name_member(NSPACE_TODO, class_name, symname), ")\n", NIL);
}
}
}
@ -3235,7 +3235,7 @@ public:
if (!have_constructor) {
String *nname = Getattr(n, "sym:name");
String *sname = Getattr(getCurrentClass(), "sym:name");
String *cname = Swig_name_construct(sname);
String *cname = Swig_name_construct(NSPACE_TODO, sname);
handled_as_init = (Strcmp(nname, sname) == 0) || (Strcmp(nname, cname) == 0);
Delete(cname);
}
@ -3243,7 +3243,7 @@ public:
if (!have_constructor && handled_as_init) {
if (Getattr(n, "feature:shadow")) {
String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4);
String *pyaction = NewStringf("%s.%s", module, Swig_name_construct(symname));
String *pyaction = NewStringf("%s.%s", module, Swig_name_construct(NSPACE_TODO, symname));
Replaceall(pycode, "$action", pyaction);
Delete(pyaction);
Printv(f_shadow, pycode, "\n", NIL);
@ -3274,10 +3274,10 @@ public:
Printv(f_shadow, pythoncode(pythonprepend(n), tab8), "\n", NIL);
Printv(f_shadow, pass_self, NIL);
if (fastinit) {
Printv(f_shadow, tab8, module, ".", class_name, "_swiginit(self,", funcCall(Swig_name_construct(symname), callParms), ")\n", NIL);
Printv(f_shadow, tab8, module, ".", class_name, "_swiginit(self,", funcCall(Swig_name_construct(NSPACE_TODO, symname), callParms), ")\n", NIL);
} else {
Printv(f_shadow,
tab8, "this = ", funcCall(Swig_name_construct(symname), callParms), "\n",
tab8, "this = ", funcCall(Swig_name_construct(NSPACE_TODO, symname), callParms), "\n",
tab8, "try: self.this.append(this)\n", tab8, "except: self.this = this\n", NIL);
}
if (have_pythonappend(n))
@ -3291,7 +3291,7 @@ public:
if (Getattr(n, "feature:shadow")) {
String *pycode = pythoncode(Getattr(n, "feature:shadow"), "");
String *pyaction = NewStringf("%s.%s", module, Swig_name_construct(symname));
String *pyaction = NewStringf("%s.%s", module, Swig_name_construct(NSPACE_TODO, symname));
Replaceall(pycode, "$action", pyaction);
Delete(pyaction);
Printv(f_shadow_stubs, pycode, "\n", NIL);
@ -3305,7 +3305,7 @@ public:
Printv(f_shadow_stubs, tab4, docstring(n, AUTODOC_CTOR, tab4), "\n", NIL);
if (have_pythonprepend(n))
Printv(f_shadow_stubs, pythoncode(pythonprepend(n), tab4), "\n", NIL);
Printv(f_shadow_stubs, tab4, "val = ", funcCall(Swig_name_construct(symname), callParms), "\n", NIL);
Printv(f_shadow_stubs, tab4, "val = ", funcCall(Swig_name_construct(NSPACE_TODO, symname), callParms), "\n", NIL);
#ifdef USE_THISOWN
Printv(f_shadow_stubs, tab4, "val.thisown = 1\n", NIL);
#endif
@ -3335,13 +3335,13 @@ public:
if (shadow) {
if (Getattr(n, "feature:shadow")) {
String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4);
String *pyaction = NewStringf("%s.%s", module, Swig_name_destroy(symname));
String *pyaction = NewStringf("%s.%s", module, Swig_name_destroy(NSPACE_TODO, symname));
Replaceall(pycode, "$action", pyaction);
Delete(pyaction);
Printv(f_shadow, pycode, "\n", NIL);
Delete(pycode);
} else {
Printv(f_shadow, tab4, "__swig_destroy__ = ", module, ".", Swig_name_destroy(symname), "\n", NIL);
Printv(f_shadow, tab4, "__swig_destroy__ = ", module, ".", Swig_name_destroy(NSPACE_TODO, symname), "\n", NIL);
if (!have_pythonprepend(n) && !have_pythonappend(n)) {
if (proxydel) {
Printv(f_shadow, tab4, "__del__ = lambda self : None;\n", NIL);
@ -3355,7 +3355,7 @@ public:
Printv(f_shadow, pythoncode(pythonprepend(n), tab8), "\n", NIL);
#ifdef USE_THISOWN
Printv(f_shadow, tab8, "try:\n", NIL);
Printv(f_shadow, tab8, tab4, "if self.thisown: ", module, ".", Swig_name_destroy(symname), "(self)\n", NIL);
Printv(f_shadow, tab8, tab4, "if self.thisown: ", module, ".", Swig_name_destroy(NSPACE_TODO, symname), "(self)\n", NIL);
Printv(f_shadow, tab8, "except: pass\n", NIL);
#else
#endif
@ -3382,9 +3382,9 @@ public:
shadow = oldshadow;
if (shadow) {
String *mname = Swig_name_member(class_name, symname);
String *setname = Swig_name_set(mname);
String *getname = Swig_name_get(mname);
String *mname = Swig_name_member(NSPACE_TODO, class_name, symname);
String *setname = Swig_name_set(NSPACE_TODO, mname);
String *getname = Swig_name_get(NSPACE_TODO, mname);
if (shadow) {
int assignable = is_assignable(n);
if (!modern) {
@ -3419,15 +3419,15 @@ public:
if (shadow && !GetFlag(n, "wrappedasconstant")) {
String *symname = Getattr(n, "sym:name");
if (GetFlag(n, "hasconsttype")) {
String *mname = Swig_name_member(class_name, symname);
String *mname = Swig_name_member(NSPACE_TODO, class_name, symname);
Printf(f_shadow_stubs, "%s.%s = %s.%s.%s\n", class_name, symname, module, global_name, mname);
Delete(mname);
} else {
String *mname = Swig_name_member(class_name, symname);
String *getname = Swig_name_get(mname);
String *mname = Swig_name_member(NSPACE_TODO, class_name, symname);
String *getname = Swig_name_get(NSPACE_TODO, mname);
String *wrapgetname = Swig_name_wrapper(getname);
String *vargetname = NewStringf("Swig_var_%s", getname);
String *setname = Swig_name_set(mname);
String *setname = Swig_name_set(NSPACE_TODO, mname);
String *wrapsetname = Swig_name_wrapper(setname);
String *varsetname = NewStringf("Swig_var_%s", setname);
@ -3490,7 +3490,7 @@ public:
shadow = oldshadow;
if (shadow) {
Printv(f_shadow, tab4, symname, " = ", module, ".", Swig_name_member(class_name, symname), "\n", NIL);
Printv(f_shadow, tab4, symname, " = ", module, ".", Swig_name_member(NSPACE_TODO, class_name, symname), "\n", NIL);
}
return SWIG_OK;
}

4
Source/Modules/ruby.cxx
View file

@ -2115,7 +2115,7 @@ public:
/* create getter */
int addfail = 0;
String *getname = Swig_name_get(iname);
String *getname = Swig_name_get(NSPACE_TODO, iname);
getfname = Swig_name_wrapper(getname);
Setattr(n, "wrap:name", getfname);
Printv(getf->def, "SWIGINTERN VALUE\n", getfname, "(", NIL);
@ -2150,7 +2150,7 @@ public:
Printf(f_wrappers, "%s", docs);
Delete(docs);
String *setname = Swig_name_set(iname);
String *setname = Swig_name_set(NSPACE_TODO, iname);
setfname = Swig_name_wrapper(setname);
Setattr(n, "wrap:name", setfname);
Printv(setf->def, "SWIGINTERN VALUE\n", setfname, "(VALUE self, ", NIL);

5
Source/Modules/swigmod.h
View file

@ -265,7 +265,7 @@ protected:
void allow_overloading(int val = 1);
/* Wrapping class query */
int is_wrapping_class();
int is_wrapping_class() const;
/* Return the node for the current class */
Node *getCurrentClass() const;
@ -273,6 +273,9 @@ protected:
/* Return C++ mode */
int getCPlusMode() const;
/* Return the namespace for the class/enum - the nspace feature */
String *getNSpace() const;
/* Return the real name of the current class */
String *getClassName() const;

12
Source/Modules/tcl8.cxx
View file

@ -573,7 +573,7 @@ public:
/* Create a function for getting a variable */
int addfail = 0;
getf = NewWrapper();
String *getname = Swig_name_get(iname);
String *getname = Swig_name_get(NSPACE_TODO, iname);
String *getfname = Swig_name_wrapper(getname);
Setattr(n, "wrap:name", getfname);
Printv(getf->def, "SWIGINTERN const char *", getfname, "(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, char *name1, char *name2, int flags) {", NIL);
@ -605,7 +605,7 @@ public:
/* Try to create a function setting a variable */
if (is_assignable(n)) {
setf = NewWrapper();
setname = Swig_name_set(iname);
setname = Swig_name_set(NSPACE_TODO, iname);
setfname = Swig_name_wrapper(setname);
Setattr(n, "wrap:name", setfname);
if (setf) {
@ -951,7 +951,7 @@ public:
Printv(f_wrappers, "static swig_class _wrap_class_", mangled_classname, " = { \"", class_name, "\", &SWIGTYPE", SwigType_manglestr(t), ",", NIL);
if (have_constructor) {
Printf(f_wrappers, "%s", Swig_name_wrapper(Swig_name_construct(constructor_name)));
Printf(f_wrappers, "%s", Swig_name_wrapper(Swig_name_construct(NSPACE_TODO, constructor_name)));
Delete(constructor_name);
constructor_name = 0;
} else {
@ -989,7 +989,7 @@ public:
Language::memberfunctionHandler(n);
realname = iname ? iname : name;
rname = Swig_name_wrapper(Swig_name_member(class_name, realname));
rname = Swig_name_wrapper(Swig_name_member(NSPACE_TODO, class_name, realname));
if (!Getattr(n, "sym:nextSibling")) {
Printv(methods_tab, tab4, "{\"", realname, "\", ", rname, "}, \n", NIL);
}
@ -1082,11 +1082,11 @@ public:
Language::membervariableHandler(n);
Printv(attr_tab, tab4, "{ \"-", symname, "\",", NIL);
rname = Swig_name_wrapper(Swig_name_get(Swig_name_member(class_name, symname)));
rname = Swig_name_wrapper(Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)));
Printv(attr_tab, rname, ", ", NIL);
Delete(rname);
if (!GetFlag(n, "feature:immutable")) {
rname = Swig_name_wrapper(Swig_name_set(Swig_name_member(class_name, symname)));
rname = Swig_name_wrapper(Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)));
Printv(attr_tab, rname, "},\n", NIL);
Delete(rname);
} else {

15
Source/Modules/typepass.cxx
View file

@ -36,6 +36,7 @@ class TypePass:private Dispatcher {
Node *module;
int importmode;
String *nsname;
String *nssymname;
Hash *classhash;
List *normalize;
@ -296,6 +297,7 @@ class TypePass:private Dispatcher {
inclass = 0;
normalize = 0;
nsname = 0;
nssymname = 0;
classhash = Getattr(n, "classes");
emit_children(n);
normalize_list();
@ -415,6 +417,10 @@ class TypePass:private Dispatcher {
Setattr(n, "tdname", tdname);
}
}
if (nssymname) {
if (GetFlag(n, "feature:nspace"))
Setattr(n, "sym:nspace", nssymname);
}
SwigType_new_scope(scopename);
SwigType_attach_symtab(Getattr(n, "symtab"));
@ -535,7 +541,9 @@ class TypePass:private Dispatcher {
}
}
String *oldnsname = nsname;
String *oldnssymname = nssymname;
nsname = Swig_symbol_qualified(Getattr(n, "symtab"));
nssymname = Swig_symbol_qualified_language_scopename(Getattr(n, "symtab"));
symtab = Swig_symbol_setscope(Getattr(n, "symtab"));
emit_children(n);
Swig_symbol_setscope(symtab);
@ -557,6 +565,8 @@ class TypePass:private Dispatcher {
}
normalize = olist;
Delete(nssymname);
nssymname = oldnssymname;
Delete(nsname);
nsname = oldnsname;
return SWIG_OK;
@ -734,6 +744,11 @@ class TypePass:private Dispatcher {
}
Setattr(n, "enumtype", enumtype);
if (nssymname) {
if (GetFlag(n, "feature:nspace"))
Setattr(n, "sym:nspace", nssymname);
}
// This block of code is for dealing with %ignore on an enum item where the target language
// attempts to use the C enum value in the target language itself and expects the previous enum value
// to be one more than the previous value... the previous enum item might not exist if it is ignored!

57
Source/Swig/cwrap.c
View file

@ -782,7 +782,7 @@ int Swig_add_extension_code(Node *n, const String *function_name, ParmList *parm
* Converts a C++ method node to a function accessor function.
* ----------------------------------------------------------------------------- */
int Swig_MethodToFunction(Node *n, String *classname, int flags, SwigType *director_type, int is_director) {
int Swig_MethodToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, int flags, SwigType *director_type, int is_director) {
String *name, *qualifier;
ParmList *parms;
SwigType *type;
@ -896,7 +896,7 @@ int Swig_MethodToFunction(Node *n, String *classname, int flags, SwigType *direc
String *defaultargs = Getattr(n, "defaultargs");
String *code = Getattr(n, "code");
String *cname = Getattr(n, "classname") ? Getattr(n, "classname") : classname;
String *membername = Swig_name_member(cname, name);
String *membername = Swig_name_member(nspace, cname, name);
String *mangled = Swig_name_mangle(membername);
int is_smart_pointer = flags & CWRAP_SMART_POINTER;
@ -1009,7 +1009,7 @@ Node *Swig_directormap(Node *module, String *type) {
* This function creates a C wrapper for a C constructor function.
* ----------------------------------------------------------------------------- */
int Swig_ConstructorToFunction(Node *n, String *classname, String *none_comparison, String *director_ctor, int cplus, int flags) {
int Swig_ConstructorToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, String *none_comparison, String *director_ctor, int cplus, int flags) {
ParmList *parms;
Parm *prefix_args;
Parm *p;
@ -1049,7 +1049,7 @@ int Swig_ConstructorToFunction(Node *n, String *classname, String *none_comparis
String *cres;
String *defaultargs = Getattr(n, "defaultargs");
String *code = Getattr(n, "code");
String *membername = Swig_name_construct(classname);
String *membername = Swig_name_construct(nspace, classname);
String *mangled = Swig_name_mangle(membername);
/* Check if the constructor is overloaded. If so, and it has code attached, we append an extra suffix
@ -1153,7 +1153,7 @@ int Swig_ConstructorToFunction(Node *n, String *classname, String *none_comparis
* This function creates a C wrapper for a destructor function.
* ----------------------------------------------------------------------------- */
int Swig_DestructorToFunction(Node *n, String *classname, int cplus, int flags) {
int Swig_DestructorToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, int cplus, int flags) {
SwigType *type;
Parm *p;
@ -1170,7 +1170,7 @@ int Swig_DestructorToFunction(Node *n, String *classname, int cplus, int flags)
String *cres;
String *call;
String *membername, *mangled, *code;
membername = Swig_name_destroy(classname);
membername = Swig_name_destroy(nspace, classname);
mangled = Swig_name_mangle(membername);
code = Getattr(n, "code");
if (code) {
@ -1219,10 +1219,7 @@ int Swig_MembersetToFunction(Node *n, String *classname, int flags) {
SwigType *ty;
SwigType *type;
SwigType *void_type = NewString("void");
String *membername;
String *mangled;
String *self = 0;
String *sname;
int varcref = flags & CWRAP_NATURAL_VAR;
@ -1236,10 +1233,6 @@ int Swig_MembersetToFunction(Node *n, String *classname, int flags) {
name = Getattr(n, "name");
type = Getattr(n, "type");
sname = Swig_name_set(name);
membername = Swig_name_member(classname, sname);
mangled = Swig_name_mangle(membername);
t = NewString(classname);
SwigType_add_pointer(t);
parms = NewParm(t, "self", n);
@ -1262,6 +1255,11 @@ int Swig_MembersetToFunction(Node *n, String *classname, int flags) {
String *call;
String *cres;
String *code = Getattr(n, "code");
String *sname = Swig_name_set(0, name);
String *membername = Swig_name_member(0, classname, sname);
String *mangled = Swig_name_mangle(membername);
if (code) {
/* I don't think this ever gets run - WSF */
Swig_add_extension_code(n, mangled, parms, void_type, code, cparse_cplusplus, "self");
@ -1269,8 +1267,12 @@ int Swig_MembersetToFunction(Node *n, String *classname, int flags) {
call = Swig_cfunction_call(mangled, parms);
cres = NewStringf("%s;", call);
Setattr(n, "wrap:action", cres);
Delete(call);
Delete(cres);
Delete(call);
Delete(mangled);
Delete(membername);
Delete(sname);
} else {
String *call = Swig_cmemberset_call(name, type, self, varcref);
String *cres = NewStringf("%s;", call);
@ -1283,9 +1285,6 @@ int Swig_MembersetToFunction(Node *n, String *classname, int flags) {
Delete(parms);
Delete(ty);
Delete(void_type);
Delete(membername);
Delete(sname);
Delete(mangled);
Delete(self);
return SWIG_OK;
}
@ -1302,10 +1301,7 @@ int Swig_MembergetToFunction(Node *n, String *classname, int flags) {
SwigType *t;
SwigType *ty;
SwigType *type;
String *membername;
String *mangled;
String *self = 0;
String *gname;
int varcref = flags & CWRAP_NATURAL_VAR;
@ -1325,10 +1321,6 @@ int Swig_MembergetToFunction(Node *n, String *classname, int flags) {
name = Getattr(n, "name");
type = Getattr(n, "type");
gname = Swig_name_get(name);
membername = Swig_name_member(classname, gname);
mangled = Swig_name_mangle(membername);
t = NewString(classname);
SwigType_add_pointer(t);
parms = NewParm(t, "self", n);
@ -1340,8 +1332,12 @@ int Swig_MembergetToFunction(Node *n, String *classname, int flags) {
if (flags & CWRAP_EXTEND) {
String *call;
String *cres;
String *code = Getattr(n, "code");
String *gname = Swig_name_get(0, name);
String *membername = Swig_name_member(0, classname, gname);
String *mangled = Swig_name_mangle(membername);
if (code) {
/* I don't think this ever gets run - WSF */
Swig_add_extension_code(n, mangled, parms, ty, code, cparse_cplusplus, "self");
@ -1349,8 +1345,12 @@ int Swig_MembergetToFunction(Node *n, String *classname, int flags) {
call = Swig_cfunction_call(mangled, parms);
cres = Swig_cresult(ty, "result", call);
Setattr(n, "wrap:action", cres);
Delete(cres);
Delete(call);
Delete(mangled);
Delete(membername);
Delete(gname);
} else {
String *call = Swig_cmemberget_call(name, type, self, varcref);
String *cres = Swig_cresult(ty, "result", call);
@ -1362,9 +1362,6 @@ int Swig_MembergetToFunction(Node *n, String *classname, int flags) {
Setattr(n, "parms", parms);
Delete(parms);
Delete(ty);
Delete(membername);
Delete(gname);
Delete(mangled);
return SWIG_OK;
}
@ -1390,7 +1387,7 @@ int Swig_VarsetToFunction(Node *n, int flags) {
parms = NewParm(ty, name, n);
if (flags & CWRAP_EXTEND) {
String *sname = Swig_name_set(name);
String *sname = Swig_name_set(0, name);
String *mangled = Swig_name_mangle(sname);
String *call = Swig_cfunction_call(mangled, parms);
String *cres = NewStringf("%s;", call);
@ -1444,7 +1441,7 @@ int Swig_VargetToFunction(Node *n, int flags) {
ty = Swig_wrapped_var_type(type, varcref);
if (flags & CWRAP_EXTEND) {
String *sname = Swig_name_get(name);
String *sname = Swig_name_get(0, name);
String *mangled = Swig_name_mangle(sname);
call = Swig_cfunction_call(mangled, 0);
cres = Swig_cresult(ty, "result", call);

51
Source/Swig/misc.c
View file

@ -17,6 +17,9 @@ char cvsroot_misc_c[] = "$Id$";
#include <errno.h>
#include <ctype.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
static char *fake_version = 0;
@ -135,6 +138,54 @@ String *Swig_strip_c_comments(const String *s) {
return stripped;
}
/* -----------------------------------------------------------------------------
* Swig_new_subdirectory()
*
* Create the subdirectory only if the basedirectory already exists as a directory.
* basedirectory can be NULL or empty to indicate current directory.
* ----------------------------------------------------------------------------- */
String *Swig_new_subdirectory(String *basedirectory, String *subdirectory) {
String *error = 0;
struct stat st;
int current_directory = basedirectory ? (Len(basedirectory) == 0 ? 1 : 0) : 0;
if (current_directory || ((stat(Char(basedirectory), &st) == 0) && S_ISDIR(st.st_mode))) {
Iterator it;
String *dir = basedirectory ? NewString(basedirectory) : NewString("");
List *subdirs = Split(subdirectory, SWIG_FILE_DELIMITER[0], INT_MAX);
for (it = First(subdirs); it.item; it = Next(it)) {
int statdir;
String *subdirectory = it.item;
Printf(dir, "%s", subdirectory);
statdir = stat(Char(dir), &st);
if (statdir == 0) {
Printf(dir, SWIG_FILE_DELIMITER);
if (S_ISDIR(st.st_mode)) {
continue;
} else {
error = NewStringf("Cannot create directory %s", dir);
break;
}
} else {
#ifdef _WIN32
int result = mkdir(Char(dir));
#else
int result = mkdir(Char(dir), 0777);
#endif
Printf(dir, SWIG_FILE_DELIMITER);
if (result != 0 && errno != EEXIST) {
error = NewStringf("Cannot create directory %s", dir);
break;
}
}
}
} else {
error = NewStringf("Cannot create subdirectory %s under the base directory %s", subdirectory, basedirectory);
}
return error;
}
/* -----------------------------------------------------------------------------
* Swig_filename_correct()

68
Source/Swig/naming.c
View file

@ -9,6 +9,15 @@
* naming.c
*
* Functions for generating various kinds of names during code generation.
*
* Swig_name_register is used to register a format string for generating names.
* The format string makes use of the following format specifiers:
*
* %c - class name is substituted
* %f - function name is substituted
* %m - member name is substituted
* %n - namespace is substituted
* %v - variable name is substituted
* ----------------------------------------------------------------------------- */
char cvsroot_naming_c[] = "$Id$";
@ -125,6 +134,23 @@ static int name_mangle(String *r) {
return special;
}
/* -----------------------------------------------------------------------------
* replace_nspace()
*
* Mangles in the namespace from nspace by replacing %n in name if nspace feature required.
* ----------------------------------------------------------------------------- */
static void replace_nspace(String *name, const_String_or_char_ptr nspace) {
if (nspace) {
String *namspace = NewStringf("%s_", nspace);
Replaceall(namspace, NSPACE_SEPARATOR, "_");
Replace(name, "%n", namspace, DOH_REPLACE_ANY);
Delete(namspace);
} else {
Replace(name, "%n", "", DOH_REPLACE_ANY);
}
}
/* -----------------------------------------------------------------------------
* Swig_name_mangle()
*
@ -172,7 +198,7 @@ String *Swig_name_wrapper(const_String_or_char_ptr fname) {
* Returns the name of a class method.
* ----------------------------------------------------------------------------- */
String *Swig_name_member(const_String_or_char_ptr classname, const_String_or_char_ptr mname) {
String *Swig_name_member(const_String_or_char_ptr nspace, const_String_or_char_ptr classname, const_String_or_char_ptr membername) {
String *r;
String *f;
String *rclassname;
@ -184,7 +210,7 @@ String *Swig_name_member(const_String_or_char_ptr classname, const_String_or_cha
naming_hash = NewHash();
f = Getattr(naming_hash, "member");
if (!f) {
Append(r, "%c_%m");
Append(r, "%n%c_%m");
} else {
Append(r, f);
}
@ -192,8 +218,9 @@ String *Swig_name_member(const_String_or_char_ptr classname, const_String_or_cha
if ((strncmp(cname, "struct ", 7) == 0) || ((strncmp(cname, "class ", 6) == 0)) || ((strncmp(cname, "union ", 6) == 0))) {
cname = strchr(cname, ' ') + 1;
}
replace_nspace(r, nspace);
Replace(r, "%c", cname, DOH_REPLACE_ANY);
Replace(r, "%m", mname, DOH_REPLACE_ANY);
Replace(r, "%m", membername, DOH_REPLACE_ANY);
/* name_mangle(r); */
Delete(rclassname);
return r;
@ -205,7 +232,7 @@ String *Swig_name_member(const_String_or_char_ptr classname, const_String_or_cha
* Returns the name of the accessor function used to get a variable.
* ----------------------------------------------------------------------------- */
String *Swig_name_get(const_String_or_char_ptr vname) {
String *Swig_name_get(const_String_or_char_ptr nspace, const_String_or_char_ptr vname) {
String *r;
String *f;
@ -218,10 +245,12 @@ String *Swig_name_get(const_String_or_char_ptr vname) {
naming_hash = NewHash();
f = Getattr(naming_hash, "get");
if (!f) {
Append(r, "%v_get");
Append(r, "%n%v_get");
} else {
Append(r, f);
}
replace_nspace(r, nspace);
Replace(r, "%v", vname, DOH_REPLACE_ANY);
/* name_mangle(r); */
return r;
@ -233,7 +262,7 @@ String *Swig_name_get(const_String_or_char_ptr vname) {
* Returns the name of the accessor function used to set a variable.
* ----------------------------------------------------------------------------- */
String *Swig_name_set(const_String_or_char_ptr vname) {
String *Swig_name_set(const_String_or_char_ptr nspace, const_String_or_char_ptr vname) {
String *r;
String *f;
@ -242,10 +271,12 @@ String *Swig_name_set(const_String_or_char_ptr vname) {
naming_hash = NewHash();
f = Getattr(naming_hash, "set");
if (!f) {
Append(r, "%v_set");
Append(r, "%n%v_set");
} else {
Append(r, f);
}
replace_nspace(r, nspace);
Replace(r, "%v", vname, DOH_REPLACE_ANY);
/* name_mangle(r); */
return r;
@ -257,7 +288,7 @@ String *Swig_name_set(const_String_or_char_ptr vname) {
* Returns the name of the accessor function used to create an object.
* ----------------------------------------------------------------------------- */
String *Swig_name_construct(const_String_or_char_ptr classname) {
String *Swig_name_construct(const_String_or_char_ptr nspace, const_String_or_char_ptr classname) {
String *r;
String *f;
String *rclassname;
@ -269,7 +300,7 @@ String *Swig_name_construct(const_String_or_char_ptr classname) {
naming_hash = NewHash();
f = Getattr(naming_hash, "construct");
if (!f) {
Append(r, "new_%c");
Append(r, "new_%n%c");
} else {
Append(r, f);
}
@ -278,6 +309,8 @@ String *Swig_name_construct(const_String_or_char_ptr classname) {
if ((strncmp(cname, "struct ", 7) == 0) || ((strncmp(cname, "class ", 6) == 0)) || ((strncmp(cname, "union ", 6) == 0))) {
cname = strchr(cname, ' ') + 1;
}
replace_nspace(r, nspace);
Replace(r, "%c", cname, DOH_REPLACE_ANY);
Delete(rclassname);
return r;
@ -290,7 +323,7 @@ String *Swig_name_construct(const_String_or_char_ptr classname) {
* Returns the name of the accessor function used to copy an object.
* ----------------------------------------------------------------------------- */
String *Swig_name_copyconstructor(const_String_or_char_ptr classname) {
String *Swig_name_copyconstructor(const_String_or_char_ptr nspace, const_String_or_char_ptr classname) {
String *r;
String *f;
String *rclassname;
@ -302,7 +335,7 @@ String *Swig_name_copyconstructor(const_String_or_char_ptr classname) {
naming_hash = NewHash();
f = Getattr(naming_hash, "copy");
if (!f) {
Append(r, "copy_%c");
Append(r, "copy_%n%c");
} else {
Append(r, f);
}
@ -312,6 +345,7 @@ String *Swig_name_copyconstructor(const_String_or_char_ptr classname) {
cname = strchr(cname, ' ') + 1;
}
replace_nspace(r, nspace);
Replace(r, "%c", cname, DOH_REPLACE_ANY);
Delete(rclassname);
return r;
@ -323,7 +357,7 @@ String *Swig_name_copyconstructor(const_String_or_char_ptr classname) {
* Returns the name of the accessor function used to destroy an object.
* ----------------------------------------------------------------------------- */
String *Swig_name_destroy(const_String_or_char_ptr classname) {
String *Swig_name_destroy(const_String_or_char_ptr nspace, const_String_or_char_ptr classname) {
String *r;
String *f;
String *rclassname;
@ -334,7 +368,7 @@ String *Swig_name_destroy(const_String_or_char_ptr classname) {
naming_hash = NewHash();
f = Getattr(naming_hash, "destroy");
if (!f) {
Append(r, "delete_%c");
Append(r, "delete_%n%c");
} else {
Append(r, f);
}
@ -343,6 +377,8 @@ String *Swig_name_destroy(const_String_or_char_ptr classname) {
if ((strncmp(cname, "struct ", 7) == 0) || ((strncmp(cname, "class ", 6) == 0)) || ((strncmp(cname, "union ", 6) == 0))) {
cname = strchr(cname, ' ') + 1;
}
replace_nspace(r, nspace);
Replace(r, "%c", cname, DOH_REPLACE_ANY);
Delete(rclassname);
return r;
@ -355,7 +391,7 @@ String *Swig_name_destroy(const_String_or_char_ptr classname) {
* Returns the name of the accessor function used to disown an object.
* ----------------------------------------------------------------------------- */
String *Swig_name_disown(const_String_or_char_ptr classname) {
String *Swig_name_disown(const_String_or_char_ptr nspace, const_String_or_char_ptr classname) {
String *r;
String *f;
String *rclassname;
@ -366,7 +402,7 @@ String *Swig_name_disown(const_String_or_char_ptr classname) {
naming_hash = NewHash();
f = Getattr(naming_hash, "disown");
if (!f) {
Append(r, "disown_%c");
Append(r, "disown_%n%c");
} else {
Append(r, f);
}
@ -375,6 +411,8 @@ String *Swig_name_disown(const_String_or_char_ptr classname) {
if ((strncmp(cname, "struct ", 7) == 0) || ((strncmp(cname, "class ", 6) == 0)) || ((strncmp(cname, "union ", 6) == 0))) {
cname = strchr(cname, ' ') + 1;
}
replace_nspace(r, nspace);
Replace(r, "%c", cname, DOH_REPLACE_ANY);
Delete(rclassname);
return r;

26
Source/Swig/swig.h
View file

@ -35,6 +35,10 @@ extern "C" {
#define SWIG_ERROR 0
#define SWIG_NOWRAP 0
/* Global macros */
#define NSPACE_SEPARATOR "." /* Namespace separator for the nspace feature - this should be changed to a target language configurable variable */
#define NSPACE_TODO 0 /* temporary TODO hack */
/* Short names for common data types */
typedef DOH String;
@ -212,6 +216,7 @@ extern "C" {
extern void Swig_symbol_setscopename(const_String_or_char_ptr name);
extern String *Swig_symbol_getscopename(void);
extern String *Swig_symbol_qualifiedscopename(Symtab *symtab);
extern String *Swig_symbol_qualified_language_scopename(Symtab *symtab);
extern Symtab *Swig_symbol_newscope(void);
extern Symtab *Swig_symbol_setscope(Symtab *);
extern Symtab *Swig_symbol_getscope(const_String_or_char_ptr symname);
@ -259,13 +264,13 @@ extern int ParmList_is_compactdefargs(ParmList *p);
extern void Swig_name_unregister(const_String_or_char_ptr method);
extern String *Swig_name_mangle(const_String_or_char_ptr s);
extern String *Swig_name_wrapper(const_String_or_char_ptr fname);
extern String *Swig_name_member(const_String_or_char_ptr classname, const_String_or_char_ptr mname);
extern String *Swig_name_get(const_String_or_char_ptr vname);
extern String *Swig_name_set(const_String_or_char_ptr vname);
extern String *Swig_name_construct(const_String_or_char_ptr classname);
extern String *Swig_name_copyconstructor(const_String_or_char_ptr classname);
extern String *Swig_name_destroy(const_String_or_char_ptr classname);
extern String *Swig_name_disown(const_String_or_char_ptr classname);
extern String *Swig_name_member(const_String_or_char_ptr nspace, const_String_or_char_ptr classname, const_String_or_char_ptr membername);
extern String *Swig_name_get(const_String_or_char_ptr nspace, const_String_or_char_ptr vname);
extern String *Swig_name_set(const_String_or_char_ptr nspace, const_String_or_char_ptr vname);
extern String *Swig_name_construct(const_String_or_char_ptr nspace, const_String_or_char_ptr classname);
extern String *Swig_name_copyconstructor(const_String_or_char_ptr nspace, const_String_or_char_ptr classname);
extern String *Swig_name_destroy(const_String_or_char_ptr nspace, const_String_or_char_ptr classname);
extern String *Swig_name_disown(const_String_or_char_ptr nspace, const_String_or_char_ptr classname);
extern void Swig_naming_init(void);
extern void Swig_name_namewarn_add(String *prefix, String *name, SwigType *decl, Hash *namewrn);
@ -296,6 +301,7 @@ extern int ParmList_is_compactdefargs(ParmList *p);
extern void Swig_banner(File *f);
extern void Swig_banner_target_lang(File *f, const_String_or_char_ptr commentchar);
extern String *Swig_strip_c_comments(const String *s);
extern String *Swig_new_subdirectory(String *basedirectory, String *subdirectory);
extern void Swig_filename_correct(String *filename);
extern String *Swig_filename_escape(String *filename);
extern void Swig_filename_unescape(String *filename);
@ -346,9 +352,9 @@ extern int ParmList_is_compactdefargs(ParmList *p);
/* --- Transformations --- */
extern int Swig_MethodToFunction(Node *n, String *classname, int flags, SwigType *director_type, int is_director);
extern int Swig_ConstructorToFunction(Node *n, String *classname, String *none_comparison, String *director_ctor, int cplus, int flags);
extern int Swig_DestructorToFunction(Node *n, String *classname, int cplus, int flags);
extern int Swig_MethodToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, int flags, SwigType *director_type, int is_director);
extern int Swig_ConstructorToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, String *none_comparison, String *director_ctor, int cplus, int flags);
extern int Swig_DestructorToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, int cplus, int flags);
extern int Swig_MembersetToFunction(Node *n, String *classname, int flags);
extern int Swig_MembergetToFunction(Node *n, String *classname, int flags);
extern int Swig_VargetToFunction(Node *n, int flags);

15
Source/Swig/symbol.c
View file

@ -353,6 +353,21 @@ String *Swig_symbol_qualifiedscopename(Symtab *symtab) {
return result;
}
/* -----------------------------------------------------------------------------
* Swig_symbol_qualified_language_scopename()
*
* Get the fully qualified C scopename of a symbol table but using a language
* specific separator for the scopenames. Basically the same as
* Swig_symbol_qualifiedscopename() but using the different separator.
* ----------------------------------------------------------------------------- */
String *Swig_symbol_qualified_language_scopename(Symtab *n) {
/* TODO: fix for %rename to work */
String *result = Swig_symbol_qualifiedscopename(n);
Replaceall(result, "::", NSPACE_SEPARATOR);
return result;
}
/* -----------------------------------------------------------------------------
* Swig_symbol_newscope()
*