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

merge revisions 11877-12162 from trunk to gsoc2009-matevz

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/branches/gsoc2009-matevz@12164 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
William S Fulton 2010-07-20 23:35:40 +00:00
commit 25ff4e4927
563 changed files with 22912 additions and 17189 deletions
Download patch file Download diff file Expand all files Collapse all files

9
Source/Modules/allegrocl.cxx
View file

@ -1669,13 +1669,8 @@ int ALLEGROCL::top(Node *n) {
Printf(f_clhead, "(in-package :%s)\n", module_name);
// Swig_print_tree(n);
Language::top(n);
// SwigType_emit_type_table(f_runtime,f_cxx_wrapper);
// Swig_print_tree(n);
#ifdef ALLEGROCL_TYPE_DEBUG
dump_linked_types(stderr);
#endif
@ -1714,6 +1709,8 @@ int ALLEGROCL::top(Node *n) {
We don't need a dispatch function in the C++ wrapper
code; we want it over on the lisp side. */
#define Swig_overload_rank Allegrocl_swig_overload_rank
#define MAX_OVERLOAD 256
/* Overload "argc" and "argv" */
@ -2538,7 +2535,7 @@ int ALLEGROCL::emit_defun(Node *n, File *fcl) {
// NewStringf("(push (swig-ff-call%s) ACL_result)", wrap->locals)));
String *ldestructor = Copy(lclass);
if (ff_foreign_ptr)
Replaceall(ldestructor, ldestructor, "identity");
Replaceall(ldestructor, ldestructor, "cl::identity");
else
Replaceall(ldestructor, ":type :class", ":type :destructor");
Replaceall(wrap->code, "$ldestructor", ldestructor);

8
Source/Modules/chicken.cxx
View file

@ -677,7 +677,7 @@ int CHICKEN::variableWrapper(Node *n) {
String *wname = NewString("");
String *mangle = NewString("");
String *tm;
String *tm2 = NewString("");;
String *tm2 = NewString("");
String *argnum = NewString("0");
String *arg = NewString("argv[0]");
Wrapper *f;
@ -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;
}

445
Source/Modules/csharp.cxx
View file

@ -54,7 +54,9 @@ class CSHARP: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),
@ -162,19 +166,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
* a namespace 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 (namespce)
proxyname = NewStringf("%s.%s.%s", namespce, nspace, symname);
else
proxyname = NewStringf("%s.%s", nspace, symname);
} else {
proxyname = Copy(symname);
}
Setattr(n, "proxyname", proxyname);
Delete(proxyname);
}
}
}
return proxyname;
}
/* -----------------------------------------------------------------------------
* directorClassName()
@ -219,6 +239,10 @@ public:
if (argv[i + 1]) {
namespce = NewString("");
Printf(namespce, argv[i + 1]);
if (Len(namespce) == 0) {
Delete(namespce);
namespce = 0;
}
Swig_mark_arg(i);
Swig_mark_arg(i + 1);
i++;
@ -358,8 +382,6 @@ public:
dmethods_table = NewHash();
n_dmethods = 0;
n_directors = 0;
if (!namespce)
namespce = NewString("");
if (!dllimport)
dllimport = Copy(module_class_name);
@ -389,8 +411,8 @@ public:
Swig_name_register("wrapper", "CSharp_%f");
if (old_variable_names) {
Swig_name_register("set", "set_%v");
Swig_name_register("get", "get_%v");
Swig_name_register("set", "set_%n%v");
Swig_name_register("get", "get_%n%v");
}
Printf(f_wrappers, "\n#ifdef __cplusplus\n");
@ -419,7 +441,7 @@ public:
// Start writing out the intermediary class file
emitBanner(f_im);
addOpenNamespace(namespce, f_im);
addOpenNamespace(0, f_im);
if (imclass_imports)
Printf(f_im, "%s\n", imclass_imports);
@ -443,7 +465,7 @@ public:
// Finish off the class
Printf(f_im, "}\n");
addCloseNamespace(namespce, f_im);
addCloseNamespace(0, f_im);
Close(f_im);
}
@ -463,7 +485,7 @@ public:
// Start writing out the module class file
emitBanner(f_module);
addOpenNamespace(namespce, f_module);
addOpenNamespace(0, f_module);
if (module_imports)
Printf(f_module, "%s\n", module_imports);
@ -495,7 +517,7 @@ public:
// Finish off the class
Printf(f_module, "}\n");
addCloseNamespace(namespce, f_module);
addCloseNamespace(0, f_module);
Close(f_module);
}
@ -690,7 +712,7 @@ public:
Swig_restore(n);
native_function_flag = false;
} else {
Printf(stderr, "%s : Line %d. No return type for %%native method %s.\n", input_file, line_number, Getattr(n, "wrap:name"));
Swig_error(input_file, line_number, "No return type for %%native method %s.\n", Getattr(n, "wrap:name"));
}
return SWIG_OK;
@ -783,7 +805,7 @@ public:
return SWIG_OK;
}
Printv(imclass_class_code, "\n [DllImport(\"", dllimport, "\", EntryPoint=\"CSharp_", overloaded_name, "\")]\n", NIL);
Printv(imclass_class_code, "\n [DllImport(\"", dllimport, "\", EntryPoint=\"", wname, "\")]\n", NIL);
if (im_outattributes)
Printf(imclass_class_code, " %s\n", im_outattributes);
@ -919,7 +941,7 @@ public:
// below based on Swig_VargetToFunction()
SwigType *ty = Swig_wrapped_var_type(Getattr(n, "type"), use_naturalvar_mode(n));
Setattr(n, "wrap:action", NewStringf("result = (%s) %s;", SwigType_lstr(ty, 0), Getattr(n, "value")));
Setattr(n, "wrap:action", NewStringf("result = (%s)(%s);", SwigType_lstr(ty, 0), Getattr(n, "value")));
}
Swig_director_emit_dynamic_cast(n, f);
@ -1033,7 +1055,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(getNSpace(), Swig_name_member(0, proxy_class_name, variable_name))) != 0;
String *getter_setter_name = NewString("");
if (!getter_flag)
@ -1106,6 +1128,22 @@ public:
if (getCurrentClass() && (cplus_mode != PUBLIC))
return SWIG_NOWRAP;
String *nspace = Getattr(n, "sym:nspace"); // NSpace/getNSpace() only works during Language::enumDeclaration call
if (proxy_flag && !is_wrapping_class()) {
// Global enums / enums in a namespace
assert(!full_imclass_name);
if (!nspace) {
full_imclass_name = NewStringf("%s", imclass_name);
} else {
if (namespce) {
full_imclass_name = NewStringf("%s.%s", namespce, imclass_name);
} else {
full_imclass_name = NewStringf("%s", imclass_name);
}
}
}
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;
@ -1115,6 +1153,17 @@ public:
if ((enum_feature != SimpleEnum) && symname && typemap_lookup_type) {
// Wrap (non-anonymous) C/C++ enum within a typesafe, typeunsafe or proper C# enum
String *scope = 0;
if (nspace || proxy_class_name) {
scope = NewString("");
if (nspace)
Printf(scope, "%s", nspace);
if (proxy_class_name)
Printv(scope, nspace ? "." : "", proxy_class_name, NIL);
}
if (!addSymbol(symname, n, scope))
return SWIG_ERROR;
// Pure C# baseclass and interfaces
const String *pure_baseclass = typemapLookup(n, "csbase", typemap_lookup_type, WARN_NONE);
const String *pure_interfaces = typemapLookup(n, "csinterfaces", typemap_lookup_type, WARN_NONE);
@ -1128,6 +1177,7 @@ public:
Printv(enum_code, typemapLookup(n, "csclassmodifiers", typemap_lookup_type, WARN_CSHARP_TYPEMAP_CLASSMOD_UNDEF), // Class modifiers (enum modifiers really)
" ", symname, (*Char(pure_baseclass) || *Char(pure_interfaces)) ? " : " : "", pure_baseclass, ((*Char(pure_baseclass)) && *Char(pure_interfaces)) ? // Interfaces
", " : "", pure_interfaces, " {\n", NIL);
Delete(scope);
} else {
// Wrap C++ enum with integers - just indicate start of enum with a comment, no comment for anonymous enums of any sort
if (symname && !Getattr(n, "unnamedinstance"))
@ -1163,7 +1213,8 @@ 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.cs", SWIG_output_directory(), symname);
String *output_directory = outputDirectory(nspace);
String *filen = NewStringf("%s%s.cs", output_directory, symname);
File *f_enum = NewFile(filen, "w", SWIG_output_files());
if (!f_enum) {
FileErrorDisplay(filen);
@ -1176,14 +1227,14 @@ public:
// Start writing out the enum file
emitBanner(f_enum);
addOpenNamespace(namespce, f_enum);
addOpenNamespace(nspace, f_enum);
Printv(f_enum, typemapLookup(n, "csimports", typemap_lookup_type, WARN_NONE), // Import statements
"\n", enum_code, "\n", NIL);
addCloseNamespace(namespce, f_enum);
addCloseNamespace(nspace, f_enum);
Close(f_enum);
Delete(output_directory);
}
} else {
// Wrap C++ enum with simple constant
@ -1196,6 +1247,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;
}
@ -1215,6 +1271,7 @@ public:
Node *parent = parentNode(n);
int unnamedinstance = GetFlag(parent, "unnamedinstance");
String *parent_name = Getattr(parent, "name");
String *nspace = getNSpace();
String *tmpValue;
// Strange hack from parent method
@ -1225,8 +1282,38 @@ public:
// Note that this is used in enumValue() amongst other places
Setattr(n, "value", tmpValue);
// Deal with enum values that are bools
if (SwigType_type(Getattr(n, "type")) == T_BOOL) {
String *boolValue = NewStringf("%s ? 1 : 0", Getattr(n, "enumvalue"));
Setattr(n, "enumvalue", boolValue);
Delete(boolValue);
}
{
EnumFeature enum_feature = decodeEnumFeature(parent);
// Add to language symbol table
String *scope = 0;
if (unnamedinstance || !parent_name || enum_feature == SimpleEnum) {
if (proxy_class_name) {
scope = NewString("");
if (nspace)
Printf(scope, "%s.", nspace);
Printf(scope, "%s", proxy_class_name);
} else {
scope = Copy(module_class_name);
}
} else {
scope = NewString("");
if (nspace)
Printf(scope, "%s.", nspace);
if (proxy_class_name)
Printf(scope, "%s.", proxy_class_name);
Printf(scope, "%s",Getattr(parent, "sym:name"));
}
if (!addSymbol(name, n, scope))
return SWIG_ERROR;
const String *csattributes = Getattr(n, "feature:cs:attributes");
if ((enum_feature == ProperEnum) && parent_name && !unnamedinstance) {
@ -1291,6 +1378,7 @@ public:
Setattr(parent, "enumvalues", Copy(symname));
else
Printv(enumvalues, ", ", symname, NIL);
Delete(scope);
}
Delete(tmpValue);
@ -1320,9 +1408,21 @@ public:
bool is_enum_item = (Cmp(nodeType(n), "enumitem") == 0);
const String *itemname = (proxy_flag && wrapping_member_flag) ? variable_name : symname;
String *scope = proxy_flag && wrapping_member_flag ? proxy_class_name : module_class_name;
if (!addSymbol(itemname, n, scope))
return SWIG_ERROR;
if (!is_enum_item) {
String *scope = 0;
if (proxy_class_name) {
String *nspace = getNSpace();
scope = NewString("");
if (nspace)
Printf(scope, "%s.", nspace);
Printf(scope, "%s", proxy_class_name);
} else {
scope = Copy(module_class_name);
}
if (!addSymbol(itemname, n, scope))
return SWIG_ERROR;
Delete(scope);
}
// The %csconst feature determines how the constant value is obtained
int const_feature_flag = GetFlag(n, "feature:cs:const");
@ -1381,13 +1481,14 @@ 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, full_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, full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), symname));
}
} else
Printf(constants_code, "%s.%s();\n", imclass_name, Swig_name_get(symname));
} else {
Printf(constants_code, "%s.%s();\n", full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), symname));
}
// Each constant and enum value is wrapped with a separate PInvoke function call
SetFlag(n, "feature:immutable");
@ -1492,7 +1593,7 @@ public:
Delete(module_interfaces);
module_interfaces = Copy(strvalue);
} else {
Printf(stderr, "%s : Line %d. Unrecognized pragma.\n", input_file, line_number);
Swig_error(input_file, line_number, "Unrecognized pragma.\n");
}
Delete(strvalue);
}
@ -1641,7 +1742,8 @@ public:
Printf(proxy_class_code, " if (SwigDerivedClassHasMethod(\"%s\", swigMethodTypes%s))\n", method, methid);
Printf(proxy_class_code, " swigDelegate%s = new SwigDelegate%s_%s(SwigDirector%s);\n", methid, proxy_class_name, methid, overname);
}
Printf(proxy_class_code, " %s.%s_director_connect(swigCPtr", imclass_name, proxy_class_name);
String *director_connect_method_name = Swig_name_member(getNSpace(), proxy_class_name, "director_connect");
Printf(proxy_class_code, " %s.%s(swigCPtr", imclass_name, director_connect_method_name);
for (i = first_class_dmethod; i < curr_class_dmethod; ++i) {
UpcallData *udata = Getitem(dmethods_seq, i);
String *methid = Getattr(udata, "class_methodidx");
@ -1703,6 +1805,7 @@ public:
director_method_types = NULL;
Delete(director_connect_parms);
director_connect_parms = NULL;
Delete(director_connect_method_name);
}
Delete(attributes);
@ -1712,33 +1815,48 @@ public:
Printv(proxy_class_def, typemapLookup(n, "cscode", typemap_lookup_type, WARN_NONE), // extra C# code
"\n", NIL);
// Substitute various strings into the above template
Replaceall(proxy_class_code, "$csclassname", proxy_class_name);
Replaceall(proxy_class_def, "$csclassname", proxy_class_name);
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, "$dllimport", dllimport);
Replaceall(proxy_class_code, "$dllimport", dllimport);
// Add code to do C++ casting to base class (only for classes in an inheritance hierarchy)
if (derived) {
Printv(imclass_cppcasts_code, "\n [DllImport(\"", dllimport, "\", EntryPoint=\"CSharp_", proxy_class_name, "Upcast", "\")]\n", NIL);
Printf(imclass_cppcasts_code, " public static extern IntPtr $csclassnameUpcast(IntPtr objectRef);\n");
String *smartptr = Getattr(n, "feature:smartptr");
String *upcast_method = Swig_name_member(getNSpace(), proxy_class_name, smartptr != 0 ? "SWIGSmartPtrUpcast" : "SWIGUpcast");
String *wname = Swig_name_wrapper(upcast_method);
Printv(imclass_cppcasts_code, "\n [DllImport(\"", dllimport, "\", EntryPoint=\"", wname, "\")]\n", NIL);
Printf(imclass_cppcasts_code, " public static extern IntPtr %s(IntPtr jarg1);\n", upcast_method);
Replaceall(imclass_cppcasts_code, "$csclassname", proxy_class_name);
Printv(upcasts_code,
"SWIGEXPORT $cbaseclass * SWIGSTDCALL CSharp_$imclazznameUpcast",
"($cclass *objectRef) {\n", " return ($cbaseclass *)objectRef;\n" "}\n", "\n", NIL);
Replaceall(upcasts_code, "$cbaseclass", c_baseclass);
Replaceall(upcasts_code, "$imclazzname", proxy_class_name);
Replaceall(upcasts_code, "$cclass", c_classname);
if (smartptr) {
SwigType *spt = Swig_cparse_type(smartptr);
if (spt) {
SwigType *smart = SwigType_typedef_resolve_all(spt);
Delete(spt);
SwigType *bsmart = Copy(smart);
SwigType *rclassname = SwigType_typedef_resolve_all(c_classname);
SwigType *rbaseclass = SwigType_typedef_resolve_all(c_baseclass);
Replaceall(bsmart, rclassname, rbaseclass);
Delete(rclassname);
Delete(rbaseclass);
String *smartnamestr = SwigType_namestr(smart);
String *bsmartnamestr = SwigType_namestr(bsmart);
Printv(upcasts_code,
"SWIGEXPORT ", bsmartnamestr, " * SWIGSTDCALL ", wname, "(", smartnamestr, " *jarg1) {\n",
" return jarg1 ? new ", bsmartnamestr, "(*jarg1) : 0;\n"
"}\n", "\n", NIL);
Delete(bsmartnamestr);
Delete(smartnamestr);
Delete(bsmart);
} else {
Swig_error(Getfile(n), Getline(n), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, c_classname);
}
} else {
Printv(upcasts_code,
"SWIGEXPORT ", c_baseclass, " * SWIGSTDCALL ", wname, "(", c_classname, " *jarg1) {\n",
" return (", c_baseclass, " *)jarg1;\n"
"}\n", "\n", NIL);
}
Delete(wname);
Delete(upcast_method);
}
Delete(baseclass);
}
@ -1749,24 +1867,38 @@ public:
virtual int classHandler(Node *n) {
String *nspace = getNSpace();
File *f_proxy = NULL;
if (proxy_flag) {
proxy_class_name = NewString(Getattr(n, "sym:name"));
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 (namespce) {
full_proxy_class_name = NewStringf("%s.%s.%s", namespce, nspace, proxy_class_name);
full_imclass_name = NewStringf("%s.%s", namespce, imclass_name);
} else {
full_proxy_class_name = NewStringf("%s.%s", nspace, proxy_class_name);
full_imclass_name = NewStringf("%s", imclass_name);
}
}
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.cs", SWIG_output_directory(), proxy_class_name);
String *output_directory = outputDirectory(nspace);
String *filen = NewStringf("%s%s.cs", output_directory, proxy_class_name);
f_proxy = NewFile(filen, "w", SWIG_output_files());
if (!f_proxy) {
FileErrorDisplay(filen);
@ -1779,7 +1911,7 @@ public:
// Start writing out the proxy class file
emitBanner(f_proxy);
addOpenNamespace(namespce, f_proxy);
addOpenNamespace(nspace, f_proxy);
Clear(proxy_class_def);
Clear(proxy_class_code);
@ -1794,12 +1926,24 @@ public:
emitProxyClassDefAndCPPCasts(n);
String *csclazzname = Swig_name_member(getNSpace(), proxy_class_name, ""); // mangled full proxy class name
Replaceall(proxy_class_def, "$csclassname", proxy_class_name);
Replaceall(proxy_class_code, "$csclassname", proxy_class_name);
Replaceall(proxy_class_constants_code, "$csclassname", proxy_class_name);
Replaceall(proxy_class_def, "$csclazzname", csclazzname);
Replaceall(proxy_class_code, "$csclazzname", csclazzname);
Replaceall(proxy_class_constants_code, "$csclazzname", csclazzname);
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);
Replaceall(proxy_class_def, "$dllimport", dllimport);
Replaceall(proxy_class_code, "$dllimport", dllimport);
Replaceall(proxy_class_constants_code, "$dllimport", dllimport);
@ -1811,7 +1955,7 @@ public:
Printv(f_proxy, proxy_class_constants_code, NIL);
Printf(f_proxy, "}\n");
addCloseNamespace(namespce, f_proxy);
addCloseNamespace(nspace, f_proxy);
Close(f_proxy);
f_proxy = NULL;
@ -1820,14 +1964,16 @@ public:
downcasts, making the constructorHandler() a bad place (because ABCs don't get to
have constructors emitted.) */
if (GetFlag(n, "feature:javadowncast")) {
String *downcast_method = Swig_name_member(getNSpace(), proxy_class_name, "SWIGDowncast");
String *wname = Swig_name_wrapper(downcast_method);
String *norm_name = SwigType_namestr(Getattr(n, "name"));
Printf(imclass_class_code, " public final static native %s downcast%s(long cPtrBase, boolean cMemoryOwn);\n", proxy_class_name, proxy_class_name);
Printf(imclass_class_code, " public final static native %s %s(long cPtrBase, boolean cMemoryOwn);\n", proxy_class_name, downcast_method);
Wrapper *dcast_wrap = NewWrapper();
Printf(dcast_wrap->def, "SWIGEXPORT jobject SWIGSTDCALL CSharp_downcast%s(JNIEnv *jenv, jclass jcls, jlong jCPtrBase, jboolean cMemoryOwn) {",
proxy_class_name);
Printf(dcast_wrap->def, "SWIGEXPORT jobject SWIGSTDCALL %s(JNIEnv *jenv, jclass jcls, jlong jCPtrBase, jboolean cMemoryOwn) {", wname);
Printf(dcast_wrap->code, " Swig::Director *director = (Swig::Director *) 0;\n");
Printf(dcast_wrap->code, " jobject jresult = (jobject) 0;\n");
Printf(dcast_wrap->code, " %s *obj = *((%s **)&jCPtrBase);\n", norm_name, norm_name);
@ -1838,12 +1984,21 @@ public:
Wrapper_print(dcast_wrap, f_wrappers);
DelWrapper(dcast_wrap);
Delete(norm_name);
Delete(wname);
Delete(downcast_method);
}
emitDirectorExtraMethods(n);
Delete(csclazzname);
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(proxy_class_constants_code);
@ -1862,7 +2017,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);
@ -1882,7 +2037,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);
@ -1962,7 +2117,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(getNSpace(), Swig_name_member(0, proxy_class_name, variable_name))) == 0);
if (setter_flag)
Swig_typemap_attach_parms("csvarin", l, NULL);
}
@ -2005,7 +2160,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");
@ -2132,7 +2287,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);
@ -2250,7 +2405,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 *csattributes = Getattr(n, "feature:cs:attributes");
@ -2270,7 +2425,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);
@ -2451,7 +2606,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);
}
return SWIG_OK;
}
@ -2577,7 +2732,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(getNSpace(), variable_name)) == 0);
if (setter_flag)
Printf(func_name, "set");
else
@ -2848,10 +3003,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(0, proxy_class_name, symname)));
}
}
}
@ -2863,26 +3018,41 @@ public:
* ----------------------------------------------------------------------------- */
String *getEnumName(SwigType *t) {
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) {
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) {
enumname = NewStringf("%s.%s", proxyname, symname);
} else {
// global enum or enum in a namespace
String *nspace = Getattr(n, "sym:nspace");
if (nspace) {
if (namespce)
enumname = NewStringf("%s.%s.%s", namespce, nspace, symname);
else
enumname = NewStringf("%s.%s", nspace, symname);
} else {
enumname = Copy(symname);
}
}
Setattr(n, "enumname", enumname);
Delete(enumname);
Delete(scopename_prefix);
}
if (proxyname)
enum_name = NewStringf("%s.%s", proxyname, symname);
else
enum_name = NewStringf("%s", symname);
Delete(scopename_prefix);
}
}
return enum_name;
return enumname;
}
/* -----------------------------------------------------------------------------
@ -2915,8 +3085,10 @@ public:
if (Strstr(tm, "$*csclassname")) {
SwigType *classnametype = Copy(strippedtype);
Delete(SwigType_pop(classnametype));
substituteClassnameSpecialVariable(classnametype, tm, "$*csclassname");
substitution_performed = true;
if (Len(classnametype) > 0) {
substituteClassnameSpecialVariable(classnametype, tm, "$*csclassname");
substitution_performed = true;
}
Delete(classnametype);
}
if (Strstr(tm, "$&csclassname")) {
@ -3019,7 +3191,7 @@ public:
// Start writing out the type wrapper class file
emitBanner(f_swigtype);
addOpenNamespace(namespce, f_swigtype);
addOpenNamespace(0, f_swigtype);
// Pure C# baseclass and interfaces
const String *pure_baseclass = typemapLookup(n, "csbase", type, WARN_NONE);
@ -3048,7 +3220,7 @@ public:
Printv(f_swigtype, swigtype, NIL);
addCloseNamespace(namespce, f_swigtype);
addCloseNamespace(0, f_swigtype);
Close(f_swigtype);
Delete(swigtype);
@ -3123,20 +3295,48 @@ public:
* addOpenNamespace()
* ----------------------------------------------------------------------------- */
void addOpenNamespace(String *namspace, File *file) {
if (namspace)
if (Len(namspace) > 0)
Printf(file, "namespace %s {\n", namspace);
void addOpenNamespace(const String *nspace, File *file) {
if (namespce || nspace) {
Printf(file, "namespace ");
if (namespce)
Printv(file, namespce, nspace ? "." : "", NIL);
if (nspace)
Printv(file, nspace, NIL);
Printf(file, " {\n");
}
}
/* -----------------------------------------------------------------------------
* addCloseNamespace()
* ----------------------------------------------------------------------------- */
void addCloseNamespace(String *namspace, File *file) {
if (namspace)
if (Len(namspace) > 0)
Printf(file, "\n}\n");
void addCloseNamespace(const String *nspace, File *file) {
if (namespce || nspace)
Printf(file, "\n}\n");
}
/* -----------------------------------------------------------------------------
* 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;
}
/*----------------------------------------------------------------------
@ -3180,8 +3380,7 @@ public:
/*----------------------------------------------------------------------
* emitDirectorExtraMethods()
*
* This is where the director connect method is
* generated.
* This is where the director connect method is generated.
*--------------------------------------------------------------------*/
void emitDirectorExtraMethods(Node *n) {
if (!Swig_directorclass(n))
@ -3189,15 +3388,16 @@ public:
// Output the director connect method:
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 *wname = Swig_name_wrapper(swig_director_connect);
String *sym_name = Getattr(n, "sym:name");
Wrapper *code_wrap;
Printv(imclass_class_code, "\n [DllImport(\"", dllimport, "\", EntryPoint=\"CSharp_", swig_director_connect, "\")]\n", NIL);
Printv(imclass_class_code, "\n [DllImport(\"", dllimport, "\", EntryPoint=\"", wname, "\")]\n", NIL);
Printf(imclass_class_code, " public static extern void %s(HandleRef jarg1", swig_director_connect);
code_wrap = NewWrapper();
Printf(code_wrap->def, "SWIGEXPORT void SWIGSTDCALL CSharp_%s(void *objarg", swig_director_connect);
Printf(code_wrap->def, "SWIGEXPORT void SWIGSTDCALL %s(void *objarg", wname);
Printf(code_wrap->code, " %s *obj = (%s *)objarg;\n", norm_name, norm_name);
Printf(code_wrap->code, " SwigDirector_%s *director = dynamic_cast<SwigDirector_%s *>(obj);\n", sym_name, sym_name);
@ -3226,6 +3426,7 @@ public:
Wrapper_print(code_wrap, f_wrappers);
DelWrapper(code_wrap);
Delete(wname);
Delete(swig_director_connect);
}
@ -3279,7 +3480,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) {
@ -3713,7 +3914,7 @@ public:
int classDirectorConstructor(Node *n) {
Node *parent = parentNode(n);
String *decl = Getattr(n, "decl");;
String *decl = Getattr(n, "decl");
String *supername = Swig_class_name(parent);
String *classname = directorClassName(parent);
String *sub = NewString("");

34
Source/Modules/emit.cxx
View file

@ -462,32 +462,40 @@ String *emit_action(Node *n) {
Printf(eaction, "try {\n");
}
String *preaction = Getattr(n, "wrap:preaction");
if (preaction)
Printv(eaction, preaction, NIL);
Printv(eaction, action, NIL);
String *postaction = Getattr(n, "wrap:postaction");
if (postaction)
Printv(eaction, postaction, NIL);
if (catchlist) {
int unknown_catch = 0;
Printf(eaction, "}\n");
for (Parm *ep = catchlist; ep; ep = nextSibling(ep)) {
String *em = Swig_typemap_lookup("throws", ep, "_e", 0);
if (em) {
SwigType *et = Getattr(ep, "type");
SwigType *etr = SwigType_typedef_resolve_all(et);
if (SwigType_isreference(etr) || SwigType_ispointer(etr) || SwigType_isarray(etr)) {
Printf(eaction, "catch(%s) {", SwigType_str(et, "_e"));
} else if (SwigType_isvarargs(etr)) {
Printf(eaction, "catch(...) {");
} else {
Printf(eaction, "catch(%s) {", SwigType_str(et, "&_e"));
}
Printv(eaction, em, "\n", NIL);
Printf(eaction, "}\n");
SwigType *et = Getattr(ep, "type");
SwigType *etr = SwigType_typedef_resolve_all(et);
if (SwigType_isreference(etr) || SwigType_ispointer(etr) || SwigType_isarray(etr)) {
Printf(eaction, "catch(%s) {", SwigType_str(et, "_e"));
} else if (SwigType_isvarargs(etr)) {
Printf(eaction, "catch(...) {");
} else {
Printf(eaction, "catch(%s) {", SwigType_str(et, "&_e"));
}
Printv(eaction, em, "\n", NIL);
Printf(eaction, "}\n");
} else {
Swig_warning(WARN_TYPEMAP_THROW, Getfile(n), Getline(n), "No 'throws' typemap defined for exception type '%s'\n", SwigType_str(Getattr(ep, "type"), 0));
unknown_catch = 1;
unknown_catch = 1;
}
}
if (unknown_catch) {
Printf(eaction, "catch(...) { throw; }\n");
Printf(eaction, "catch(...) { throw; }\n");
}
}

4753
Source/Modules/go.cxx Normal file
View file

File diff suppressed because it is too large Load diff

10
Source/Modules/guile.cxx
View file

@ -114,7 +114,7 @@ static String *memberfunction_name = 0;
extern "C" {
static int has_classname(Node *class_node) {
return Getattr(class_node, "guile:goopsclassname") != NULL;
return Getattr(class_node, "guile:goopsclassname") ? 1 : 0;
}
}
@ -254,7 +254,7 @@ public:
}
// set default value for primsuffix
if (primsuffix == NULL)
if (!primsuffix)
primsuffix = NewString("primitive");
//goops support can only be enabled if passive or module linkage is used
@ -628,7 +628,7 @@ public:
if (maybe_delimiter && Len(output) > 0 && Len(tm) > 0) {
Printv(output, maybe_delimiter, NIL);
}
const String *pn = (name == NULL) ? (const String *) Getattr(p, "name") : name;
const String *pn = !name ? (const String *) Getattr(p, "name") : name;
String *pt = Getattr(p, "type");
Replaceall(tm, "$name", pn); // legacy for $parmname
Replaceall(tm, "$type", SwigType_str(pt, 0));
@ -657,7 +657,7 @@ public:
Parm *p;
String *proc_name = 0;
char source[256];
Wrapper *f = NewWrapper();;
Wrapper *f = NewWrapper();
String *cleanup = NewString("");
String *outarg = NewString("");
String *signature = NewString("");
@ -781,7 +781,7 @@ public:
if (strcmp("void", Char(pt)) != 0) {
Node *class_node = Swig_symbol_clookup_check(pb, Getattr(n, "sym:symtab"),
has_classname);
String *goopsclassname = (class_node == NULL) ? NULL : Getattr(class_node, "guile:goopsclassname");
String *goopsclassname = !class_node ? NULL : Getattr(class_node, "guile:goopsclassname");
/* do input conversion */
if (goopsclassname) {
Printv(method_signature, " (", argname, " ", goopsclassname, ")", NIL);

501
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 (package)
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()
@ -214,6 +234,10 @@ public:
if (argv[i + 1]) {
package = NewString("");
Printf(package, argv[i + 1]);
if (Len(package) == 0) {
Delete(package);
package = 0;
}
Swig_mark_arg(i);
Swig_mark_arg(i + 1);
i++;
@ -370,8 +394,6 @@ public:
dmethods_table = NewHash();
n_dmethods = 0;
n_directors = 0;
if (!package)
package = NewString("");
jnipackage = NewString("");
package_path = NewString("");
@ -400,7 +422,7 @@ public:
String *wrapper_name = NewString("");
if (Len(package)) {
if (package) {
String *jniname = makeValidJniName(package);
Printv(jnipackage, jniname, NIL);
Delete(jniname);
@ -410,13 +432,13 @@ 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));
if (old_variable_names) {
Swig_name_register("set", "set_%v");
Swig_name_register("get", "get_%v");
Swig_name_register("set", "set_%n%v");
Swig_name_register("get", "get_%n%v");
}
Delete(wrapper_name);
@ -447,7 +469,7 @@ public:
// Start writing out the intermediary class file
emitBanner(f_im);
if (Len(package) > 0)
if (package)
Printf(f_im, "package %s;\n", package);
if (imclass_imports)
@ -498,7 +520,7 @@ public:
// Start writing out the module class file
emitBanner(f_module);
if (Len(package) > 0)
if (package)
Printf(f_module, "package %s;\n", package);
if (module_imports)
@ -550,7 +572,7 @@ public:
// Start writing out the Java constants interface file
emitBanner(f_module);
if (Len(package) > 0)
if (package)
Printf(f_module, "package %s;\n", package);
if (module_imports)
@ -763,7 +785,7 @@ public:
Swig_restore(n);
native_function_flag = false;
} else {
Printf(stderr, "%s : Line %d. No return type for %%native method %s.\n", input_file, line_number, Getattr(n, "wrap:name"));
Swig_error(input_file, line_number, "No return type for %%native method %s.\n", Getattr(n, "wrap:name"));
}
return SWIG_OK;
@ -1002,7 +1024,7 @@ public:
// below based on Swig_VargetToFunction()
SwigType *ty = Swig_wrapped_var_type(Getattr(n, "type"), use_naturalvar_mode(n));
Setattr(n, "wrap:action", NewStringf("result = (%s) %s;", SwigType_lstr(ty, 0), Getattr(n, "value")));
Setattr(n, "wrap:action", NewStringf("result = (%s)(%s);", SwigType_lstr(ty, 0), Getattr(n, "value")));
}
// Now write code to make the function call
@ -1099,7 +1121,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 +1189,24 @@ public:
if (getCurrentClass() && (cplus_mode != PUBLIC))
return SWIG_NOWRAP;
String *nspace = Getattr(n, "sym:nspace"); // NSpace/getNSpace() only works during Language::enumDeclaration call
if (proxy_flag && !is_wrapping_class()) {
// Global enums / enums in a namespace
assert(!full_imclass_name);
if (!nspace) {
full_imclass_name = NewStringf("%s", imclass_name);
} else {
if (package) {
full_imclass_name = NewStringf("%s.%s", package, imclass_name);
} else {
String *name = Getattr(n, "name") ? Getattr(n, "name") : NewString("<unnamed>");
Swig_error(Getfile(n), Getline(n), "The nspace feature used on '%s' is not supported unless a package is specified with -package - Java does not support types declared in a named package accessing types declared in an unnamed package.\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;
@ -1176,6 +1216,17 @@ public:
if ((enum_feature != SimpleEnum) && symname && typemap_lookup_type) {
// Wrap (non-anonymous) C/C++ enum within a typesafe, typeunsafe or proper Java enum
String *scope = 0;
if (nspace || proxy_class_name) {
scope = NewString("");
if (nspace)
Printf(scope, "%s", nspace);
if (proxy_class_name)
Printv(scope, nspace ? "." : "", proxy_class_name, NIL);
}
if (!addSymbol(symname, n, scope))
return SWIG_ERROR;
// Pure Java baseclass and interfaces
const String *pure_baseclass = typemapLookup(n, "javabase", typemap_lookup_type, WARN_NONE);
const String *pure_interfaces = typemapLookup(n, "javainterfaces", typemap_lookup_type, WARN_NONE);
@ -1189,6 +1240,7 @@ public:
Replaceall(enum_code, "$static ", "static ");
else
Replaceall(enum_code, "$static ", "");
Delete(scope);
} else {
// Wrap C++ enum with integers - just indicate start of enum with a comment, no comment for anonymous enums of any sort
if (symname && !Getattr(n, "unnamedinstance"))
@ -1224,7 +1276,8 @@ 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 *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 +1290,21 @@ public:
// Start writing out the enum file
emitBanner(f_enum);
if (Len(package) > 0)
Printf(f_enum, "package %s;\n", package);
if (package || nspace) {
Printf(f_enum, "package ");
if (package)
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 +1317,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;
}
@ -1276,6 +1341,7 @@ public:
Node *parent = parentNode(n);
int unnamedinstance = GetFlag(parent, "unnamedinstance");
String *parent_name = Getattr(parent, "name");
String *nspace = getNSpace();
String *tmpValue;
// Strange hack from parent method
@ -1286,9 +1352,38 @@ public:
// Note that this is used in enumValue() amongst other places
Setattr(n, "value", tmpValue);
// Deal with enum values that are bools
if (SwigType_type(Getattr(n, "type")) == T_BOOL) {
String *boolValue = NewStringf("%s ? 1 : 0", Getattr(n, "enumvalue"));
Setattr(n, "enumvalue", boolValue);
Delete(boolValue);
}
{
EnumFeature enum_feature = decodeEnumFeature(parent);
// Add to language symbol table
String *scope = 0;
if (unnamedinstance || !parent_name || enum_feature == SimpleEnum) {
if (proxy_class_name) {
scope = NewString("");
if (nspace)
Printf(scope, "%s.", nspace);
Printf(scope, "%s", proxy_class_name);
} else {
scope = Copy(constants_interface_name);
}
} else {
scope = NewString("");
if (nspace)
Printf(scope, "%s.", nspace);
if (proxy_class_name)
Printf(scope, "%s.", proxy_class_name);
Printf(scope, "%s",Getattr(parent, "sym:name"));
}
if (!addSymbol(name, n, scope))
return SWIG_ERROR;
if ((enum_feature == ProperEnum) && parent_name && !unnamedinstance) {
// Wrap (non-anonymous) C/C++ enum with a proper Java enum
// Emit the enum item.
@ -1335,6 +1430,7 @@ public:
Setattr(parent, "enumvalues", Copy(symname));
else
Printv(enumvalues, ", ", symname, NIL);
Delete(scope);
}
Delete(tmpValue);
@ -1364,9 +1460,21 @@ public:
bool is_enum_item = (Cmp(nodeType(n), "enumitem") == 0);
const String *itemname = (proxy_flag && wrapping_member_flag) ? variable_name : symname;
String *scope = proxy_flag && wrapping_member_flag ? proxy_class_name : constants_interface_name;
if (!addSymbol(itemname, n, scope))
return SWIG_ERROR;
if (!is_enum_item) {
String *scope = 0;
if (proxy_class_name) {
String *nspace = getNSpace();
scope = NewString("");
if (nspace)
Printf(scope, "%s.", nspace);
Printf(scope, "%s", proxy_class_name);
} else {
scope = Copy(constants_interface_name);
}
if (!addSymbol(itemname, n, scope))
return SWIG_ERROR;
Delete(scope);
}
// The %javaconst feature determines how the constant value is obtained
int const_feature_flag = GetFlag(n, "feature:java:const");
@ -1418,13 +1526,14 @@ 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, full_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, full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), symname));
}
} else
Printf(constants_code, "%s.%s();\n", imclass_name, Swig_name_get(symname));
} else {
Printf(constants_code, "%s.%s();\n", full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), symname));
}
// Each constant and enum value is wrapped with a separate JNI function call
SetFlag(n, "feature:immutable");
@ -1528,37 +1637,37 @@ public:
Delete(module_interfaces);
module_interfaces = Copy(strvalue);
} else if (Strcmp(code, "moduleimport") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use the moduleimports pragma.\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use the moduleimports pragma.\n");
} else if (Strcmp(code, "moduleinterface") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use the moduleinterfaces pragma.\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use the moduleinterfaces pragma.\n");
} else if (Strcmp(code, "modulemethodmodifiers") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use %%javamethodmodifiers.\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use %%javamethodmodifiers.\n");
} else if (Strcmp(code, "allshadowimport") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use %%typemap(javaimports).\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use %%typemap(javaimports).\n");
} else if (Strcmp(code, "allshadowcode") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use %%typemap(javacode).\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use %%typemap(javacode).\n");
} else if (Strcmp(code, "allshadowbase") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use %%typemap(javabase).\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use %%typemap(javabase).\n");
} else if (Strcmp(code, "allshadowinterface") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use %%typemap(javainterfaces).\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use %%typemap(javainterfaces).\n");
} else if (Strcmp(code, "allshadowclassmodifiers") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use %%typemap(javaclassmodifiers).\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use %%typemap(javaclassmodifiers).\n");
} else if (proxy_flag) {
if (Strcmp(code, "shadowcode") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use %%typemap(javacode).\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use %%typemap(javacode).\n");
} else if (Strcmp(code, "shadowimport") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use %%typemap(javaimports).\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use %%typemap(javaimports).\n");
} else if (Strcmp(code, "shadowbase") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use %%typemap(javabase).\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use %%typemap(javabase).\n");
} else if (Strcmp(code, "shadowinterface") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use %%typemap(javainterfaces).\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use %%typemap(javainterfaces).\n");
} else if (Strcmp(code, "shadowclassmodifiers") == 0) {
Printf(stderr, "%s : Line %d. Ignored: Deprecated pragma. Please use %%typemap(javaclassmodifiers).\n", input_file, line_number);
Swig_error(input_file, line_number, "Deprecated pragma. Please use %%typemap(javaclassmodifiers).\n");
} else {
Printf(stderr, "%s : Line %d. Unrecognized pragma.\n", input_file, line_number);
Swig_error(input_file, line_number, "Unrecognized pragma.\n");
}
} else {
Printf(stderr, "%s : Line %d. Unrecognized pragma.\n", input_file, line_number);
Swig_error(input_file, line_number, "Unrecognized pragma.\n");
}
Delete(strvalue);
}
@ -1691,16 +1800,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);
}
@ -1712,38 +1823,56 @@ public:
Printv(proxy_class_def, typemapLookup(n, "javacode", typemap_lookup_type, WARN_NONE), // extra Java code
"\n", NIL);
// Substitute various strings into the above template
Replaceall(proxy_class_code, "$javaclassname", proxy_class_name);
Replaceall(proxy_class_def, "$javaclassname", proxy_class_name);
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);
// 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);
Printv(upcasts_code,
"SWIGEXPORT jlong JNICALL Java_$jnipackage$imimclass_SWIG$imclazznameUpcast",
"(JNIEnv *jenv, jclass jcls, jlong jarg1) {\n",
" jlong baseptr = 0;\n"
" (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);
Replaceall(upcasts_code, "$cbaseclass", c_baseclass);
Replaceall(upcasts_code, "$imclazzname", imclazzname);
Replaceall(upcasts_code, "$cclass", c_classname);
Replaceall(upcasts_code, "$jnipackage", jnipackage);
Replaceall(upcasts_code, "$imimclass", imimclass);
Delete(imclazzname);
Delete(imimclass);
String *smartptr = Getattr(n, "feature:smartptr");
String *upcast_method = Swig_name_member(getNSpace(), proxy_class_name, smartptr != 0 ? "SWIGSmartPtrUpcast" : "SWIGUpcast");
String *jniname = makeValidJniName(upcast_method);
String *wname = Swig_name_wrapper(jniname);
Printf(imclass_cppcasts_code, " public final static native long %s(long jarg1);\n", upcast_method);
if (smartptr) {
SwigType *spt = Swig_cparse_type(smartptr);
if (spt) {
SwigType *smart = SwigType_typedef_resolve_all(spt);
Delete(spt);
SwigType *bsmart = Copy(smart);
SwigType *rclassname = SwigType_typedef_resolve_all(c_classname);
SwigType *rbaseclass = SwigType_typedef_resolve_all(c_baseclass);
Replaceall(bsmart, rclassname, rbaseclass);
Delete(rclassname);
Delete(rbaseclass);
String *smartnamestr = SwigType_namestr(smart);
String *bsmartnamestr = SwigType_namestr(bsmart);
Printv(upcasts_code,
"SWIGEXPORT jlong JNICALL ", wname, "(JNIEnv *jenv, jclass jcls, jlong jarg1) {\n",
" jlong baseptr = 0;\n"
" ", smartnamestr, " *argp1;\n"
" ", bsmartnamestr, " result;\n"
" (void)jenv;\n"
" (void)jcls;\n"
" argp1 = *(", smartnamestr, " **)&jarg1;\n"
" *(", bsmartnamestr, " **)&baseptr = argp1 ? new ", bsmartnamestr, "(*argp1) : 0;\n"
" return baseptr;\n"
"}\n", "\n", NIL);
Delete(bsmartnamestr);
Delete(smartnamestr);
Delete(bsmart);
} else {
Swig_error(Getfile(n), Getline(n), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, c_classname);
}
} else {
Printv(upcasts_code,
"SWIGEXPORT jlong JNICALL ", wname, "(JNIEnv *jenv, jclass jcls, jlong jarg1) {\n",
" jlong baseptr = 0;\n"
" (void)jenv;\n"
" (void)jcls;\n"
" *(", c_baseclass, " **)&baseptr = *(", c_classname, " **)&jarg1;\n"
" return baseptr;\n"
"}\n", "\n", NIL);
}
Delete(wname);
Delete(jniname);
Delete(upcast_method);
}
Delete(baseclass);
}
@ -1757,21 +1886,36 @@ 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 (package) {
full_proxy_class_name = NewStringf("%s.%s.%s", package, nspace, proxy_class_name);
full_imclass_name = NewStringf("%s.%s", package, imclass_name);
} else {
String *name = Getattr(n, "name") ? Getattr(n, "name") : NewString("<unnamed>");
Swig_error(Getfile(n), Getline(n), "The nspace feature used on '%s' is not supported unless a package is specified with -package - Java does not support types declared in a named package accessing types declared in an unnamed package.\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 +1928,14 @@ public:
// Start writing out the proxy class file
emitBanner(f_proxy);
if (Len(package) > 0)
Printf(f_proxy, "package %s;\n", package);
if (package || nspace) {
Printf(f_proxy, "package ");
if (package)
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 +1943,7 @@ public:
destructor_call = NewString("");
destructor_throws_clause = NewString("");
proxy_class_constants_code = NewString("");
Delete(output_directory);
}
Language::classHandler(n);
@ -1801,12 +1952,24 @@ public:
emitProxyClassDefAndCPPCasts(n);
String *javaclazzname = Swig_name_member(getNSpace(), proxy_class_name, ""); // mangled full proxy class name
Replaceall(proxy_class_def, "$javaclassname", proxy_class_name);
Replaceall(proxy_class_code, "$javaclassname", proxy_class_name);
Replaceall(proxy_class_constants_code, "$javaclassname", proxy_class_name);
Replaceall(proxy_class_def, "$javaclazzname", javaclazzname);
Replaceall(proxy_class_code, "$javaclazzname", javaclazzname);
Replaceall(proxy_class_constants_code, "$javaclazzname", javaclazzname);
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
@ -1822,16 +1985,17 @@ public:
downcasts, making the constructorHandler() a bad place (because ABCs don't get to
have constructors emitted.) */
if (GetFlag(n, "feature:javadowncast")) {
String *jni_imclass_name = makeValidJniName(imclass_name);
String *jni_class_name = makeValidJniName(proxy_class_name);
String *downcast_method = Swig_name_member(getNSpace(), proxy_class_name, "SWIGDowncast");
String *jniname = makeValidJniName(downcast_method);
String *wname = Swig_name_wrapper(jniname);
String *norm_name = SwigType_namestr(Getattr(n, "name"));
Printf(imclass_class_code, " public final static native %s downcast%s(long cPtrBase, boolean cMemoryOwn);\n", proxy_class_name, proxy_class_name);
Printf(imclass_class_code, " public final static native %s %s(long cPtrBase, boolean cMemoryOwn);\n", proxy_class_name, downcast_method);
Wrapper *dcast_wrap = NewWrapper();
Printf(dcast_wrap->def, "SWIGEXPORT jobject JNICALL Java_%s%s_downcast%s(JNIEnv *jenv, jclass jcls, jlong jCPtrBase, jboolean cMemoryOwn) {",
jnipackage, jni_imclass_name, jni_class_name);
Printf(dcast_wrap->def, "SWIGEXPORT jobject JNICALL %s(JNIEnv *jenv, jclass jcls, jlong jCPtrBase, jboolean cMemoryOwn) {", wname);
Printf(dcast_wrap->code, " Swig::Director *director = (Swig::Director *) 0;\n");
Printf(dcast_wrap->code, " jobject jresult = (jobject) 0;\n");
Printf(dcast_wrap->code, " %s *obj = *((%s **)&jCPtrBase);\n", norm_name, norm_name);
@ -1842,12 +2006,22 @@ public:
Wrapper_print(dcast_wrap, f_wrappers);
DelWrapper(dcast_wrap);
Delete(norm_name);
Delete(wname);
Delete(jniname);
Delete(downcast_method);
}
emitDirectorExtraMethods(n);
Delete(javaclazzname);
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 +2043,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 +2065,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 +2141,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 +2152,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 +2295,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 +2357,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 +2369,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 +2542,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 +2650,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 +2855,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(0, proxy_class_name, symname)));
}
}
}
@ -2698,28 +2872,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 (package)
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;
}
/* -----------------------------------------------------------------------------
@ -2753,8 +2943,10 @@ public:
if (Strstr(tm, "$*javaclassname")) {
SwigType *classnametype = Copy(strippedtype);
Delete(SwigType_pop(classnametype));
substituteClassnameSpecialVariable(classnametype, tm, "$*javaclassname", jnidescriptor);
substitution_performed = true;
if (Len(classnametype) > 0) {
substituteClassnameSpecialVariable(classnametype, tm, "$*javaclassname", jnidescriptor);
substitution_performed = true;
}
Delete(classnametype);
}
if (Strstr(tm, "$&javaclassname")) {
@ -2858,7 +3050,7 @@ public:
// Start writing out the type wrapper class file
emitBanner(f_swigtype);
if (Len(package) > 0)
if (package)
Printf(f_swigtype, "package %s;\n", package);
// Pure Java baseclass and interfaces
@ -3004,10 +3196,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 +3237,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
*--------------------------------------------------------------------*/
@ -3145,8 +3361,7 @@ public:
/*----------------------------------------------------------------------
* emitDirectorExtraMethods()
*
* This is where the $javaclassname_director_connect is
* generated.
* This is where the director connect method is generated.
*--------------------------------------------------------------------*/
void emitDirectorExtraMethods(Node *n) {
if (!Swig_directorclass(n))
@ -3155,13 +3370,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 +3398,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 +3557,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) {
@ -3885,7 +4100,7 @@ public:
int classDirectorConstructor(Node *n) {
Node *parent = parentNode(n);
String *decl = Getattr(n, "decl");;
String *decl = Getattr(n, "decl");
String *supername = Swig_class_name(parent);
String *classname = directorClassName(parent);
String *sub = NewString("");

116
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);
@ -1611,9 +1612,15 @@ int Language::externDeclaration(Node *n) {
* ---------------------------------------------------------------------- */
int Language::enumDeclaration(Node *n) {
String *oldNSpace = NSpace;
NSpace = Getattr(n, "sym:nspace");
if (!ImportMode) {
emit_children(n);
}
NSpace = oldNSpace;
return SWIG_OK;
}
@ -1676,7 +1683,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(0, ClassPrefix, symname);
Setattr(n, "sym:name", mrename);
String *new_name = 0;
@ -1908,7 +1915,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);
@ -1917,7 +1924,7 @@ int Language::classDirectorDisown(Node *n) {
Delete(type);
type = NewString("void");
String *action = NewString("");
Printv(action, "{\n", "Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);\n", "if (director) director->swig_disown();\n", "}\n", NULL);
Printv(action, "{\n", "Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);\n", "if (director) director->swig_disown();\n", "}\n", NULL);
Setfile(disown, Getfile(n));
Setline(disown, Getline(n));
Setattr(disown, "wrap:action", action);
@ -2354,6 +2361,8 @@ int Language::classDeclaration(Node *n) {
InClass = 1;
CurrentClass = n;
String *oldNSpace = NSpace;
NSpace = Getattr(n, "sym:nspace");
/* Call classHandler() here */
if (!ImportMode) {
@ -2403,6 +2412,7 @@ int Language::classDeclaration(Node *n) {
Language::classHandler(n);
}
NSpace = oldNSpace;
InClass = 0;
CurrentClass = 0;
Delete(ClassType);
@ -2635,7 +2645,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 +2657,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 +2674,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);
@ -2687,7 +2697,7 @@ int Language::destructorDeclaration(Node *n) {
if (!CurrentClass)
return SWIG_NOWRAP;
if (cplus_mode != PUBLIC)
if (cplus_mode != PUBLIC && !Getattr(CurrentClass, "feature:unref"))
return SWIG_NOWRAP;
if (ImportMode)
return SWIG_NOWRAP;
@ -2739,9 +2749,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 +2854,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 +2889,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 +2932,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();
@ -2940,7 +2950,10 @@ int Language::addSymbol(const String *s, const Node *n, const_String_or_char_ptr
} else {
Node *c = Getattr(symbols, s);
if (c && (c != n)) {
Swig_error(input_file, line_number, "'%s' is multiply defined in the generated target language module.\n", s);
if (scope)
Swig_error(input_file, line_number, "'%s' is multiply defined in the generated target language module in scope %s.\n", s, scope);
else
Swig_error(input_file, line_number, "'%s' is multiply defined in the generated target language module.\n", s);
Swig_error(Getfile(c), Getline(c), "Previous declaration of '%s'\n", s);
return 0;
}
@ -2982,7 +2995,10 @@ void Language::dumpSymbols() {
* ----------------------------------------------------------------------------- */
Node *Language::symbolLookup(String *s, const_String_or_char_ptr scope) {
Hash *symbols = Getattr(symtabs, scope);
Hash *symbols = Getattr(symtabs, scope ? scope : "");
if (!symbols) {
return NULL;
}
return Getattr(symbols, s);
}
@ -3001,8 +3017,6 @@ Node *Language::classLookup(SwigType *s) {
Symtab *stab = 0;
SwigType *ty1 = SwigType_typedef_resolve_all(s);
SwigType *ty2 = SwigType_strip_qualifiers(ty1);
Delete(ty1);
ty1 = 0;
String *base = SwigType_base(ty2);
@ -3039,11 +3053,18 @@ Node *Language::classLookup(SwigType *s) {
if (n) {
/* Found a match. Look at the prefix. We only allow
the cases where where we want a proxy class for the particular type */
if ((Len(prefix) == 0) || // simple type (pass by value)
(Strcmp(prefix, "p.") == 0) || // pointer
(Strcmp(prefix, "r.") == 0) || // reference
(Strcmp(prefix, "r.p.") == 0) || // pointer by reference
SwigType_prefix_is_simple_1D_array(prefix)) { // Simple 1D array (not arrays of pointers/references)
bool acceptable_prefix =
(Len(prefix) == 0) || // simple type (pass by value)
(Strcmp(prefix, "p.") == 0) || // pointer
(Strcmp(prefix, "r.") == 0) || // reference
SwigType_prefix_is_simple_1D_array(prefix); // Simple 1D array (not arrays of pointers/references)
// Also accept pointer by const reference, not non-const pointer reference
if (!acceptable_prefix && (Strcmp(prefix, "r.p.") == 0)) {
Delete(prefix);
prefix = SwigType_prefix(ty1);
acceptable_prefix = (Strncmp(prefix, "r.q(const", 9) == 0);
}
if (acceptable_prefix) {
SwigType *cs = Copy(s);
Setattr(classtypes, cs, n);
Delete(cs);
@ -3051,9 +3072,10 @@ Node *Language::classLookup(SwigType *s) {
n = 0;
}
}
Delete(ty2);
Delete(base);
Delete(prefix);
Delete(base);
Delete(ty2);
Delete(ty1);
}
if (n && (GetFlag(n, "feature:ignore") || Getattr(n, "feature:onlychildren"))) {
n = 0;
@ -3079,10 +3101,6 @@ Node *Language::enumLookup(SwigType *s) {
SwigType *lt = SwigType_ltype(s);
SwigType *ty1 = SwigType_typedef_resolve_all(lt);
SwigType *ty2 = SwigType_strip_qualifiers(ty1);
Delete(lt);
Delete(ty1);
lt = 0;
ty1 = 0;
String *base = SwigType_base(ty2);
@ -3121,9 +3139,11 @@ Node *Language::enumLookup(SwigType *s) {
n = 0;
}
}
Delete(ty2);
Delete(base);
Delete(prefix);
Delete(base);
Delete(ty2);
Delete(ty1);
Delete(lt);
}
if (n && (GetFlag(n, "feature:ignore"))) {
n = 0;
@ -3306,7 +3326,7 @@ bool Language::extraDirectorProtectedCPPMethodsRequired() const {
* Language::is_wrapping_class()
* ----------------------------------------------------------------------------- */
int Language::is_wrapping_class() {
int Language::is_wrapping_class() const {
return InClass;
}
@ -3318,6 +3338,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

65
Source/Modules/main.cxx
View file

@ -197,11 +197,11 @@ enum { STAGE1=1, STAGE2=2, STAGE3=4, STAGE4=8, STAGEOVERFLOW=16 };
static List *libfiles = 0;
static List *all_output_files = 0;
// -----------------------------------------------------------------------------
// check_suffix()
//
// Checks the suffix of a file to see if we should emit extern declarations.
// -----------------------------------------------------------------------------
/* -----------------------------------------------------------------------------
* check_suffix()
*
* Checks the suffix of a file to see if we should emit extern declarations.
* ----------------------------------------------------------------------------- */
static int check_suffix(String *filename) {
const char *name = Char(filename);
@ -216,10 +216,11 @@ static int check_suffix(String *filename) {
return 0;
}
// -----------------------------------------------------------------------------
// install_opts(int argc, char *argv[])
// Install all command line options as preprocessor symbols
// -----------------------------------------------------------------------------
/* -----------------------------------------------------------------------------
* install_opts()
*
* Install all command line options as preprocessor symbols
* ----------------------------------------------------------------------------- */
static void install_opts(int argc, char *argv[]) {
int i;
@ -255,11 +256,12 @@ static void install_opts(int argc, char *argv[]) {
}
}
// -----------------------------------------------------------------------------
// decode_numbers_list(String *numlist)
// Decode comma separated list into a binary number of the inputs or'd together
// eg list="1,4" will return (2^0 || 2^3) = 0x1001
// -----------------------------------------------------------------------------
/* -----------------------------------------------------------------------------
* decode_numbers_list()
*
* Decode comma separated list into a binary number of the inputs or'd together
* eg list="1,4" will return (2^0 || 2^3) = 0x1001
* ----------------------------------------------------------------------------- */
static unsigned int decode_numbers_list(String *numlist) {
unsigned int decoded_number = 0;
@ -279,22 +281,25 @@ static unsigned int decode_numbers_list(String *numlist) {
return decoded_number;
}
// -----------------------------------------------------------------------------
// Sets the output directory for language specific (proxy) files if not set and
// adds trailing file separator if necessary.
// -----------------------------------------------------------------------------
/* -----------------------------------------------------------------------------
* Sets the output directory for language specific (proxy) files if not set and
* corrects the directory name and adds trailing file separator if necessary.
* ----------------------------------------------------------------------------- */
static void set_outdir(const String *c_wrapper_file_dir) {
static void configure_outdir(const String *c_wrapper_file_dir) {
// Add file delimiter if not present in output directory name
if (outdir && Len(outdir) != 0) {
// Use the C wrapper file's directory if the output directory has not been set by user
if (!outdir || Len(outdir) == 0)
outdir = NewString(c_wrapper_file_dir);
Swig_filename_correct(outdir);
// Add trailing file delimiter if not present in output directory name
if (Len(outdir) > 0) {
const char *outd = Char(outdir);
if (strcmp(outd + strlen(outd) - strlen(SWIG_FILE_DELIMITER), SWIG_FILE_DELIMITER) != 0)
Printv(outdir, SWIG_FILE_DELIMITER, NIL);
}
// Use the C wrapper file's directory if the output directory has not been set by user
if (!outdir)
outdir = NewString(c_wrapper_file_dir);
}
/* This function sets the name of the configuration file */
@ -1221,7 +1226,7 @@ int SWIG_main(int argc, char *argv[], Language *l) {
} else {
Setattr(top, "outfile_h", outfile_name_h);
}
set_outdir(Swig_file_dirname(Getattr(top, "outfile")));
configure_outdir(Swig_file_dirname(Getattr(top, "outfile")));
if (Swig_contract_mode_get()) {
Swig_contracts(top);
}
@ -1290,11 +1295,11 @@ int SWIG_main(int argc, char *argv[], Language *l) {
return Swig_error_count();
}
// --------------------------------------------------------------------------
// SWIG_exit(int exit_code)
//
// Cleanup and either freeze or exit
// --------------------------------------------------------------------------
/* -----------------------------------------------------------------------------
* SWIG_exit()
*
* Cleanup and either freeze or exit
* ----------------------------------------------------------------------------- */
void SWIG_exit(int exit_code) {
while (freeze) {

24
Source/Modules/modula3.cxx
View file

@ -972,8 +972,8 @@ MODULA3():
Swig_name_register("wrapper", "Modula3_%f");
if (old_variable_names) {
Swig_name_register("set", "set_%v");
Swig_name_register("get", "get_%v");
Swig_name_register("set", "set_%n%v");
Swig_name_register("get", "get_%n%v");
}
Printf(f_wrappers, "\n#ifdef __cplusplus\n");
@ -1196,7 +1196,7 @@ MODULA3():
Swig_restore(n);
native_function_flag = false;
} else {
Printf(stderr, "%s : Line %d. No return type for %%native method %s.\n", input_file, line_number, Getattr(n, "wrap:name"));
Swig_error(input_file, line_number, "No return type for %%native method %s.\n", Getattr(n, "wrap:name"));
}
return SWIG_OK;
@ -1324,7 +1324,7 @@ MODULA3():
Parm *p;
attachParameterNames(n, "tmap:name", "c:wrapname", "m3arg%d");
bool gencomma = false;
for (p = skipIgnored(l, "in"); p != NULL; p = skipIgnored(p, "in")) {
for (p = skipIgnored(l, "in"); p; p = skipIgnored(p, "in")) {
String *arg = Getattr(p, "c:wrapname");
{
@ -1422,7 +1422,7 @@ MODULA3():
// below based on Swig_VargetToFunction()
SwigType *ty = Swig_wrapped_var_type(Getattr(n, "type"), use_naturalvar_mode(n));
Setattr(n, "wrap:action", NewStringf("result = (%s) %s;", SwigType_lstr(ty, 0), Getattr(n, "value")));
Setattr(n, "wrap:action", NewStringf("result = (%s)(%s);", SwigType_lstr(ty, 0), Getattr(n, "value")));
}
Setattr(n, "wrap:name", wname);
@ -1545,7 +1545,7 @@ MODULA3():
Parm *p;
writeArgState state;
attachParameterNames(n, "tmap:rawinname", "modula3:rawname", "arg%d");
for (p = skipIgnored(l, "m3rawintype"); p != NULL; p = skipIgnored(p, "m3rawintype")) {
for (p = skipIgnored(l, "m3rawintype"); p; p = skipIgnored(p, "m3rawintype")) {
/* Get argument passing mode, should be one of VALUE, VAR, READONLY */
String *mode = Getattr(p, "tmap:m3rawinmode");
@ -1928,7 +1928,7 @@ MODULA3():
} else if (Strcmp(code, "unsafe") == 0) {
unsafe_module = true;
} else if (Strcmp(code, "library") == 0) {
if (targetlibrary != NULL) {
if (targetlibrary) {
Delete(targetlibrary);
}
targetlibrary = Copy(strvalue);
@ -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;
}

2
Source/Modules/mzscheme.cxx
View file

@ -514,7 +514,7 @@ public:
String *proc_name = NewString("");
String *tm;
String *tm2 = NewString("");;
String *tm2 = NewString("");
String *argnum = NewString("0");
String *arg = NewString("argv[0]");
Wrapper *f;

8
Source/Modules/ocaml.cxx
View file

@ -265,8 +265,8 @@ public:
Swig_register_filebyname("class_ctors", f_class_ctors);
if (old_variable_names) {
Swig_name_register("set", "%v__set__");
Swig_name_register("get", "%v__get__");
Swig_name_register("set", "%n%v__set__");
Swig_name_register("get", "%n%v__get__");
}
Swig_banner(f_begin);
@ -778,7 +778,7 @@ public:
String *proc_name = NewString("");
String *tm;
String *tm2 = NewString("");;
String *tm2 = NewString("");
String *argnum = NewString("0");
String *arg = NewString("SWIG_Field(args,0)");
Wrapper *f;
@ -1599,7 +1599,7 @@ public:
tm = Getattr(n, "feature:director:except");
}
if ((tm) && Len(tm) && (Strcmp(tm, "1") != 0)) {
Printf(w->code, "if (result == NULL) {\n");
Printf(w->code, "if (!result) {\n");
Printf(w->code, " CAML_VALUE error = *caml_named_value(\"director_except\");\n");
Replaceall(tm, "$error", "error");
Printv(w->code, Str(tm), "\n", NIL);

27
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);
@ -760,6 +760,7 @@ public:
SwigType *type = Getattr(n, "type");
String *rawval = Getattr(n, "rawval");
String *value = rawval ? rawval : Getattr(n, "value");
String *cppvalue = Getattr(n, "cppvalue");
String *tm;
if (!addSymbol(iname, n))
@ -775,7 +776,7 @@ public:
if ((tm = Swig_typemap_lookup("constcode", n, name, 0))) {
Replaceall(tm, "$source", value);
Replaceall(tm, "$target", name);
Replaceall(tm, "$value", value);
Replaceall(tm, "$value", cppvalue ? cppvalue : value);
Replaceall(tm, "$nsname", iname);
Printf(f_init, "%s\n", tm);
} else {
@ -882,7 +883,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 +916,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 +937,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);
@ -972,12 +973,12 @@ public:
Delete(self);
}
return Language::constructorHandler(n);;
return Language::constructorHandler(n);
}
virtual int destructorHandler(Node *n) {
have_destructor = 1;
return Language::destructorHandler(n);;
return Language::destructorHandler(n);
}
virtual int staticmemberfunctionHandler(Node *n) {
@ -988,7 +989,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 +1015,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);
@ -1243,7 +1244,7 @@ public:
idx = 0;
p = l;
int use_parse = 0;
while (p != NULL) {
while (p) {
if (checkAttribute(p, "tmap:in:numinputs", "0")) {
p = Getattr(p, "tmap:in:next");
continue;

2
Source/Modules/overload.cxx
View file

@ -59,7 +59,7 @@ void Wrapper_cast_dispatch_mode_set(int flag) {
* languages ignore the first method parsed.
* ----------------------------------------------------------------------------- */
static List *Swig_overload_rank(Node *n, bool script_lang_wrapping) {
List *Swig_overload_rank(Node *n, bool script_lang_wrapping) {
Overloaded nodes[MAX_OVERLOAD];
int nnodes = 0;
Node *o = Getattr(n, "sym:overloaded");

34
Source/Modules/perl5.cxx
View file

@ -308,7 +308,7 @@ public:
if (no_pmfile) {
f_pm = NewString(0);
} else {
if (pmfile == NULL) {
if (!pmfile) {
char *m = Char(module) + Len(module);
while (m != Char(module)) {
if (*m == ':') {
@ -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;
}
@ -1631,7 +1631,7 @@ public:
if (value) {
FILE *f = Swig_include_open(value);
if (!f) {
Printf(stderr, "%s : Line %d. Unable to locate file %s\n", input_file, line_number, value);
Swig_error(input_file, line_number, "Unable to locate file %s\n", value);
} else {
char buffer[4096];
while (fgets(buffer, 4095, f)) {
@ -1641,7 +1641,7 @@ public:
fclose(f);
}
} else {
Printf(stderr, "%s : Line %d. Unrecognized pragma.\n", input_file, line_number);
Swig_error(input_file, line_number, "Unrecognized pragma.\n");
}
}
}

45
Source/Modules/php.cxx
View file

@ -799,7 +799,7 @@ public:
Wrapper_add_local(f, "director", "Swig::Director *director = 0");
Printf(f->code, "director = dynamic_cast<Swig::Director*>(arg1);\n");
Wrapper_add_local(f, "upcall", "bool upcall = false");
Printf(f->code, "upcall = !director->is_overriden_method((char *)\"%s\", (char *)\"%s\");\n",
Printf(f->code, "upcall = !director->swig_is_overridden_method((char *)\"%s\", (char *)\"%s\");\n",
Swig_class_name(Swig_methodclass(n)), name);
}
@ -1206,7 +1206,7 @@ public:
}
if (!pname_cstr) {
// Unnamed parameter, e.g. int foo(int);
} else if (pname == NULL) {
} else if (!pname) {
pname = NewString(pname_cstr);
} else {
size_t len = strlen(pname_cstr);
@ -1290,7 +1290,7 @@ public:
if (errno || *p) {
Clear(value);
Append(value, "?");
} else if (strchr(Char(value), '.') == NULL) {
} else if (strchr(Char(value), '.') == 0) {
// Ensure value is a double constant, not an integer one.
Append(value, ".0");
double val2 = strtod(Char(value), &p);
@ -1496,7 +1496,7 @@ public:
Printf(prepare, "case %d: ", ++last_handled_i);
}
if (Cmp(d, "void") != 0) {
if ((!directorsEnabled() || !Swig_directorclass(n)) && !newobject) {
if ((!directorsEnabled() || !Swig_directorclass(n)) && !newobject) {
Append(prepare, "$r=");
} else {
Printf(prepare, "$this->%s=", SWIG_PTR);
@ -1576,14 +1576,21 @@ public:
}
if (Getattr(n, "access") && haspublicbase) {
Delete(acc);
acc = NewString("public");
acc = NewStringEmpty(); // implicitly public
Swig_warning(WARN_PHP_PUBLIC_BASE, input_file, line_number, Char(warnmsg));
Delete(warnmsg);
}
}
if (Cmp(acc, "") != 0) {
if (Cmp(acc, "public") == 0) {
// The default visibility for methods is public, so don't specify
// that explicitly to keep the wrapper size down.
Delete(acc);
acc = NewStringEmpty();
} else if (Cmp(acc, "") != 0) {
Append(acc, " ");
}
if (constructor) {
const char * arg0;
if (max_num_of_arguments > 0) {
@ -1632,11 +1639,13 @@ public:
Printf(output, "%s", prepare);
if (constructor) {
if (!directorsEnabled() || !Swig_directorclass(n)) {
if (strcmp(methodname, "__construct") == 0) {
Printf(output, "\t\t$this->%s=%s;\n", SWIG_PTR, invoke);
} else {
String *classname = Swig_class_name(current_class);
Printf(output, "\t\treturn new %s(%s);\n", classname, invoke);
if (!Len(prepare)) {
if (strcmp(methodname, "__construct") == 0) {
Printf(output, "\t\t$this->%s=%s;\n", SWIG_PTR, invoke);
} else {
String *classname = Swig_class_name(current_class);
Printf(output, "\t\treturn new %s(%s);\n", classname, invoke);
}
}
} else {
Node *parent = Swig_methodclass(n);
@ -1694,7 +1703,7 @@ public:
Printf(output, "\t\t\treturn new $c($r);\n");
} else {
Printf(output, "\t\t\t$c = new stdClass();\n");
Printf(output, "\t\t\t$c->_cPtr = $r;\n");
Printf(output, "\t\t\t$c->"SWIG_PTR" = $r;\n");
Printf(output, "\t\t\treturn $c;\n");
}
Printf(output, "\t\t}\n\t\treturn $r;\n");
@ -1780,8 +1789,6 @@ done:
if (!addSymbol(iname, n))
return SWIG_ERROR;
SwigType_remember(t);
/* First link C variables to PHP */
tm = Swig_typemap_lookup("varinit", n, name, 0);
@ -1789,7 +1796,7 @@ done:
Replaceall(tm, "$target", name);
Printf(s_vinit, "%s\n", tm);
} else {
Printf(stderr, "%s: Line %d, Unable to link with type %s\n", input_file, line_number, SwigType_str(t, 0));
Swig_error(input_file, line_number, "Unable to link with type %s\n", SwigType_str(t, 0));
}
/* Now generate PHP -> C sync blocks */
@ -1799,7 +1806,7 @@ done:
Replaceall(tm, "$symname", iname);
Printf(f_c->code, "%s\n", tm);
} else {
Printf(stderr,"%s: Line %d, Unable to link with type %s\n", input_file, line_number, SwigType_str(t, 0));
Swig_error(input_file, line_number, "Unable to link with type %s\n", SwigType_str(t, 0));
}
*/
/* Now generate C -> PHP sync blocks */
@ -1811,7 +1818,7 @@ done:
Replaceall(tm, "$symname", iname);
Printf(f_php->code, "%s\n", tm);
} else {
Printf(stderr,"%s: Line %d, Unable to link with type %s\n", input_file, line_number, SwigType_str(t, 0));
Swig_error(input_file, line_number, "Unable to link with type %s\n", SwigType_str(t, 0));
}
}
*/
@ -2497,7 +2504,7 @@ done:
idx = 0;
p = l;
int use_parse = 0;
while (p != NULL) {
while (p) {
if (checkAttribute(p, "tmap:in:numinputs", "0")) {
p = Getattr(p, "tmap:in:next");
continue;
@ -2566,7 +2573,7 @@ done:
}
Append(w->code, "zval *result, funcname;\n");
Append(w->code, "MAKE_STD_ZVAL(result);\n");
Printf(w->code, "ZVAL_STRING(&funcname, (char *)\"%s\", 0);\n", name);
Printf(w->code, "ZVAL_STRING(&funcname, (char *)\"%s\", 0);\n", GetChar(n, "sym:name"));
Append(w->code, "if (!swig_self) {\n");
Append(w->code, " SWIG_PHP_Error(E_ERROR, \"this pointer is NULL\");");
Append(w->code, "}\n\n");

12
Source/Modules/pike.cxx
View file

@ -159,8 +159,8 @@ public:
Printf(f_header, "#define SWIG_name \"%s\"\n\n", module);
/* Change naming scheme for constructors and destructors */
Swig_name_register("construct", "%c_create");
Swig_name_register("destroy", "%c_destroy");
Swig_name_register("construct", "%n%c_create");
Swig_name_register("destroy", "%n%c_destroy");
/* Current wrap type */
current = NO_CPP;
@ -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");

122
Source/Modules/python.cxx
View file

@ -211,6 +211,7 @@ public:
virtual void thread_begin_allow(Node *n, String *f) {
if (!GetFlag(n, "feature:nothreadallow")) {
String *bb = Getattr(n, "feature:threadbeginallow");
Append(f, "{\n");
if (bb) {
Append(f, bb);
} else {
@ -222,11 +223,13 @@ public:
virtual void thread_end_allow(Node *n, String *f) {
if (!GetFlag(n, "feature:nothreadallow")) {
String *eb = Getattr(n, "feature:threadendallow");
Append(f, "\n");
if (eb) {
Append(f, eb);
} else {
Append(f, "SWIG_PYTHON_THREAD_END_ALLOW;\n");
Append(f, "SWIG_PYTHON_THREAD_END_ALLOW;");
}
Append(f, "\n}");
}
}
@ -1070,7 +1073,7 @@ public:
bool have_docstring(Node *n) {
String *str = Getattr(n, "feature:docstring");
return (str != NULL && Len(str) > 0) || (Getattr(n, "feature:autodoc") && !GetFlag(n, "feature:noautodoc"));
return (str && Len(str) > 0) || (Getattr(n, "feature:autodoc") && !GetFlag(n, "feature:noautodoc"));
}
/* ------------------------------------------------------------
@ -1082,7 +1085,7 @@ public:
String *docstring(Node *n, autodoc_t ad_type, const String *indent, bool use_triple = true) {
String *str = Getattr(n, "feature:docstring");
bool have_ds = (str != NULL && Len(str) > 0);
bool have_ds = (str && Len(str) > 0);
bool have_auto = (Getattr(n, "feature:autodoc") && !GetFlag(n, "feature:noautodoc"));
const char *triple_double = use_triple ? "\"\"\"" : "";
String *autodoc = NULL;
@ -1098,7 +1101,7 @@ public:
if (have_auto) {
autodoc = make_autodoc(n, ad_type);
have_auto = (autodoc != NULL && Len(autodoc) > 0);
have_auto = (autodoc && Len(autodoc) > 0);
}
// If there is more than one line then make docstrings like this:
//
@ -1113,14 +1116,14 @@ public:
doc = NewString("");
Printv(doc, triple_double, "\n", pythoncode(autodoc, indent), "\n", pythoncode(str, indent), indent, triple_double, NIL);
} else if (!have_auto && have_ds) { // only docstring
if (Strchr(str, '\n') == NULL) {
if (Strchr(str, '\n') == 0) {
doc = NewStringf("%s%s%s", triple_double, str, triple_double);
} else {
doc = NewString("");
Printv(doc, triple_double, "\n", pythoncode(str, indent), indent, triple_double, NIL);
}
} else if (have_auto && !have_ds) { // only autodoc
if (Strchr(autodoc, '\n') == NULL) {
if (Strchr(autodoc, '\n') == 0) {
doc = NewStringf("%s%s%s", triple_double, autodoc, triple_double);
} else {
doc = NewString("");
@ -1358,7 +1361,7 @@ public:
{
// Only do the autodoc if there isn't a docstring for the class
String *str = Getattr(n, "feature:docstring");
if (str == NULL || Len(str) == 0) {
if (!str || Len(str) == 0) {
if (CPlusPlus) {
Printf(doc, "Proxy of C++ %s class", real_classname);
} else {
@ -1554,7 +1557,7 @@ public:
bool have_pythonprepend(Node *n) {
String *str = Getattr(n, "feature:pythonprepend");
return (str != NULL && Len(str) > 0);
return (str && Len(str) > 0);
}
/* ------------------------------------------------------------
@ -1581,7 +1584,7 @@ public:
String *str = Getattr(n, "feature:pythonappend");
if (!str)
str = Getattr(n, "feature:addtofunc");
return (str != NULL && Len(str) > 0);
return (str && Len(str) > 0);
}
/* ------------------------------------------------------------
@ -1866,7 +1869,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);
}
@ -2200,8 +2203,13 @@ public:
Append(f->code, "try {\n");
} else {
if (allow_thread) {
Append(f->code, "{\n");
thread_begin_allow(n, f->code);
String *preaction = NewString("");
thread_begin_allow(n, preaction);
Setattr(n,"wrap:preaction", preaction);
String *postaction = NewString("");
thread_end_allow(n, postaction);
Setattr(n,"wrap:postaction", postaction);
}
}
@ -2214,11 +2222,6 @@ public:
Append(actioncode, "} catch (Swig::DirectorException&) {\n");
Append(actioncode, " SWIG_fail;\n");
Append(actioncode, "}\n");
} else {
if (allow_thread) {
thread_end_allow(n, actioncode);
Append(actioncode, "}\n");
}
}
/* This part below still needs cleanup */
@ -2437,8 +2440,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);
@ -2718,15 +2721,15 @@ public:
Printf(f_directors_h, "\n\n");
Printf(f_directors_h, "/* Internal Director utilities */\n");
Printf(f_directors_h, "public:\n");
Printf(f_directors_h, " bool swig_get_inner(const char* name) const {\n");
Printf(f_directors_h, " std::map<std::string, bool>::const_iterator iv = inner.find(name);\n");
Printf(f_directors_h, " return (iv != inner.end() ? iv->second : false);\n");
Printf(f_directors_h, " bool swig_get_inner(const char* protected_method_name) const {\n");
Printf(f_directors_h, " std::map<std::string, bool>::const_iterator iv = swig_inner.find(protected_method_name);\n");
Printf(f_directors_h, " return (iv != swig_inner.end() ? iv->second : false);\n");
Printf(f_directors_h, " }\n\n");
Printf(f_directors_h, " void swig_set_inner(const char* name, bool val) const\n");
Printf(f_directors_h, " { inner[name] = val;}\n\n");
Printf(f_directors_h, " void swig_set_inner(const char* protected_method_name, bool val) const\n");
Printf(f_directors_h, " { swig_inner[protected_method_name] = val;}\n\n");
Printf(f_directors_h, "private:\n");
Printf(f_directors_h, " mutable std::map<std::string, bool> inner;\n");
Printf(f_directors_h, " mutable std::map<std::string, bool> swig_inner;\n");
}
if (director_method_index) {
@ -2738,7 +2741,7 @@ public:
Printf(f_directors_h, " if (!method) {\n");
Printf(f_directors_h, " swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);\n");
Printf(f_directors_h, " method = PyObject_GetAttr(swig_get_self(), name);\n");
Printf(f_directors_h, " if (method == NULL) {\n");
Printf(f_directors_h, " if (!method) {\n");
Printf(f_directors_h, " std::string msg = \"Method in class %s doesn't exist, undefined \";\n", classname);
Printf(f_directors_h, " msg += method_name;\n");
Printf(f_directors_h, " Swig::DirectorMethodException::raise(msg.c_str());\n");
@ -2771,7 +2774,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);
@ -2901,7 +2904,7 @@ public:
Printf(f_shadow, ":\n");
if (have_docstring(n)) {
String *str = docstring(n, AUTODOC_CLASS, tab4);
if (str != NULL && Len(str))
if (str && Len(str))
Printv(f_shadow, tab4, str, "\n", NIL);
}
if (!modern) {
@ -3029,7 +3032,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 +3096,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 +3108,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 +3121,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 +3166,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 +3180,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 +3238,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 +3246,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);
@ -3254,6 +3257,7 @@ public:
String *classname = Swig_class_name(parent);
String *rclassname = Swig_class_name(getCurrentClass());
assert(rclassname);
String *parms = make_pyParmList(n, true, false, allow_kwargs);
/* Pass 'self' only if using director */
@ -3274,10 +3278,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,21 +3295,21 @@ 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);
Delete(pycode);
} else {
String *parms = make_pyParmList(n, true, false, allow_kwargs);
String *callParms = make_pyParmList(n, true, true, allow_kwargs);
String *parms = make_pyParmList(n, false, false, allow_kwargs);
String *callParms = make_pyParmList(n, false, true, allow_kwargs);
Printv(f_shadow_stubs, "\ndef ", symname, "(", parms, ")", returnTypeAnnotation(n), ":\n", NIL);
if (have_docstring(n))
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 +3339,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 +3359,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 +3386,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 +3423,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 +3494,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;
}
@ -3719,7 +3723,7 @@ int PYTHON::classDirectorMethod(Node *n, Node *parent, String *super) {
idx = 0;
p = l;
int use_parse = 0;
while (p != NULL) {
while (p) {
if (checkAttribute(p, "tmap:in:numinputs", "0")) {
p = Getattr(p, "tmap:in:next");
continue;
@ -3906,13 +3910,13 @@ int PYTHON::classDirectorMethod(Node *n, Node *parent, String *super) {
if (tm)
tm = Copy(tm);
}
Append(w->code, "if (result == NULL) {\n");
Append(w->code, "if (!result) {\n");
Append(w->code, " PyObject *error = PyErr_Occurred();\n");
if ((tm) && Len(tm) && (Strcmp(tm, "1") != 0)) {
Replaceall(tm, "$error", "error");
Printv(w->code, Str(tm), "\n", NIL);
} else {
Append(w->code, " if (error != NULL) {\n");
Append(w->code, " if (error) {\n");
Printf(w->code, " Swig::DirectorMethodException::raise(\"Error detected when calling '%s.%s'\");\n", classname, pyname);
Append(w->code, " }\n");
}

32
Source/Modules/r.cxx
View file

@ -556,10 +556,10 @@ String * R::createFunctionPointerHandler(SwigType *t, Node *n, int *numArgs) {
ParmList *parms = SwigType_function_parms(SwigType_del_pointer(Copy(t)), n);
// if (debugMode) {
if (debugMode) {
Printf(stderr, "Type: %s\n", t);
Printf(stderr, "Return type: %s\n", SwigType_base(t));
//}
}
bool isVoidType = Strcmp(rettype, "void") == 0;
if (debugMode)
@ -1299,6 +1299,8 @@ void R::addAccessor(String *memberName, Wrapper *wrapper, String *name,
Printf(stderr, "Adding accessor: %s (%s) => %s\n", memberName, name, tmp);
}
#define Swig_overload_rank R_swig_overload_rank
#define MAX_OVERLOAD 256
struct Overloaded {
@ -1673,7 +1675,7 @@ int R::functionWrapper(Node *n) {
}
p = nextSibling(p);
}
String *unresolved_return_type =
Copy(type);
if (expandTypedef(type) &&
@ -1731,7 +1733,7 @@ int R::functionWrapper(Node *n) {
Wrapper *f = NewWrapper();
Wrapper *sfun = NewWrapper();
int isVoidReturnType = (Strcmp(type, "void") == 0);
// Need to use the unresolved return type since
// typedef resolution removes the const which causes a
@ -2036,7 +2038,13 @@ int R::functionWrapper(Node *n) {
Printv(f->code, cleanup, NIL);
Delete(cleanup);
/* Look to see if there is any newfree cleanup code */
if (GetFlag(n, "feature:new")) {
if ((tm = Swig_typemap_lookup("newfree", n, "result", 0))) {
Replaceall(tm, "$source", "result"); /* deprecated */
Printf(f->code, "%s\n", tm);
}
}
Printv(f->code, UnProtectWrapupCode, NIL);
@ -2053,7 +2061,17 @@ int R::functionWrapper(Node *n) {
Printv(sfun->code, ";", (Len(tm) ? "ans = " : ""), ".Call('", wname,
"', ", sargs, "PACKAGE='", Rpackage, "');\n", NIL);
if(Len(tm))
Printf(sfun->code, "%s\n\nans;\n", tm);
{
Printf(sfun->code, "%s\n\n", tm);
if (constructor)
{
String *finalizer = NewString(iname);
Replace(finalizer, "new_", "", DOH_REPLACE_FIRST);
Printf(sfun->code, "reg.finalizer(ans, delete_%s)\n", finalizer);
}
Printf(sfun->code, "ans\n");
}
if (destructor)
Printv(f->code, "R_ClearExternalPtr(self);\n", NIL);
@ -2496,7 +2514,7 @@ int R::membervariableHandler(Node *n) {
int status(Language::membervariableHandler(n));
if(opaqueClassDeclaration == NULL && debugMode)
if(!opaqueClassDeclaration && debugMode)
Printf(stderr, "<membervariableHandler> %s %s\n", Getattr(n, "name"), Getattr(n, "type"));
processing_member_access_function = 0;

30
Source/Modules/ruby.cxx
View file

@ -231,7 +231,7 @@ private:
bool have_docstring(Node *n) {
String *str = Getattr(n, "feature:docstring");
return (str != NULL && Len(str) > 0) || (Getattr(n, "feature:autodoc") && !GetFlag(n, "feature:noautodoc"));
return (str && Len(str) > 0) || (Getattr(n, "feature:autodoc") && !GetFlag(n, "feature:noautodoc"));
}
/* ------------------------------------------------------------
@ -244,7 +244,7 @@ private:
String *docstring(Node *n, autodoc_t ad_type) {
String *str = Getattr(n, "feature:docstring");
bool have_ds = (str != NULL && Len(str) > 0);
bool have_ds = (str && Len(str) > 0);
bool have_auto = (Getattr(n, "feature:autodoc") && !GetFlag(n, "feature:noautodoc"));
String *autodoc = NULL;
String *doc = NULL;
@ -259,7 +259,7 @@ private:
if (have_auto) {
autodoc = make_autodoc(n, ad_type);
have_auto = (autodoc != NULL && Len(autodoc) > 0);
have_auto = (autodoc && Len(autodoc) > 0);
}
// If there is more than one line then make docstrings like this:
//
@ -272,14 +272,14 @@ private:
doc = NewString("");
Printv(doc, "\n", autodoc, "\n", str, NIL);
} else if (!have_auto && have_ds) { // only docstring
if (Strchr(str, '\n') == NULL) {
if (Strchr(str, '\n') == 0) {
doc = NewString(str);
} else {
doc = NewString("");
Printv(doc, str, NIL);
}
} else if (have_auto && !have_ds) { // only autodoc
if (Strchr(autodoc, '\n') == NULL) {
if (Strchr(autodoc, '\n') == 0) {
doc = NewStringf("%s", autodoc);
} else {
doc = NewString("");
@ -618,7 +618,7 @@ private:
{
// Only do the autodoc if there isn't a docstring for the class
String *str = Getattr(n, "feature:docstring");
if (counter == 0 && (str == NULL || Len(str) == 0)) {
if (counter == 0 && (str == 0 || Len(str) == 0)) {
if (CPlusPlus) {
Printf(doc, " Proxy of C++ %s class", full_name);
} else {
@ -1248,7 +1248,11 @@ public:
Iterator alias = First(aliases);
while (alias.item) {
if (Len(alias.item) > 0) {
Printv(klass->init, tab4, "rb_define_alias(", klass->vname, ", \"", alias.item, "\", \"", iname, "\");\n", NIL);
if (multipleInheritance) {
Printv(klass->init, tab4, "rb_define_alias(", klass->mImpl, ", \"", alias.item, "\", \"", iname, "\");\n", NIL);
} else {
Printv(klass->init, tab4, "rb_define_alias(", klass->vname, ", \"", alias.item, "\", \"", iname, "\");\n", NIL);
}
}
alias = Next(alias);
}
@ -2115,7 +2119,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 +2154,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);
@ -2578,7 +2582,7 @@ public:
/* First wrap the allocate method */
current = CONSTRUCTOR_ALLOCATE;
Swig_name_register("construct", "%c_allocate");
Swig_name_register("construct", "%n%c_allocate");
Language::constructorHandler(n);
@ -2613,7 +2617,7 @@ public:
Delete(docs);
current = CONSTRUCTOR_INITIALIZE;
Swig_name_register("construct", "new_%c");
Swig_name_register("construct", "new_%n%c");
Language::constructorHandler(n);
/* Restore original parameter list */
@ -2621,7 +2625,7 @@ public:
Swig_restore(n);
/* Done */
Swig_name_unregister((const_String_or_char_ptr ) "construct");
Swig_name_unregister("construct");
current = NO_CPP;
klass->constructor_defined = 1;
return SWIG_OK;
@ -2635,7 +2639,7 @@ public:
/* First wrap the allocate method */
current = CONSTRUCTOR_ALLOCATE;
Swig_name_register("construct", "%c_allocate");
Swig_name_register("construct", "%n%c_allocate");
return Language::copyconstructorHandler(n);
}

2
Source/Modules/swigmain.cxx
View file

@ -51,6 +51,7 @@ extern "C" {
Language *swig_cffi(void);
Language *swig_uffi(void);
Language *swig_r(void);
Language *swig_go(void);
}
struct swig_module {
@ -69,6 +70,7 @@ static swig_module modules[] = {
{"-clisp", swig_clisp, "CLISP"},
{"-cffi", swig_cffi, "CFFI"},
{"-csharp", swig_csharp, "C#"},
{"-go", swig_go, "Go"},
{"-guile", swig_guile, "Guile"},
{"-java", swig_java, "Java"},
{"-lua", swig_lua, "Lua"},

8
Source/Modules/swigmod.h
View file

@ -11,8 +11,6 @@
* Main header file for SWIG modules.
* ----------------------------------------------------------------------------- */
/* $Id$ */
#ifndef SWIG_SWIGMOD_H_
#define SWIG_SWIGMOD_H_
@ -267,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;
@ -275,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;
@ -343,6 +344,7 @@ void Swig_overload_check(Node *n);
String *Swig_overload_dispatch(Node *n, const_String_or_char_ptr fmt, int *);
String *Swig_overload_dispatch_cast(Node *n, const_String_or_char_ptr fmt, int *);
String *Swig_overload_dispatch_fast(Node *n, const_String_or_char_ptr fmt, int *);
List *Swig_overload_rank(Node *n, bool script_lang_wrapping);
SwigType *cplus_value_type(SwigType *t);
/* directors.cxx start */

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 {

54
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;
@ -230,6 +231,37 @@ class TypePass:private Dispatcher {
Node *bclass = n; /* Getattr(n,"class"); */
Hash *scopes = Getattr(bclass, "typescope");
SwigType_inherit(clsname, bname, cast, 0);
String *smartptr = Getattr(first, "feature:smartptr");
if (smartptr) {
SwigType *smart = 0;
SwigType *spt = Swig_cparse_type(smartptr);
if (spt) {
smart = SwigType_typedef_resolve_all(spt);
Delete(spt);
/* Record a (fake) inheritance relationship between smart pointer
and smart pointer to base class, so that smart pointer upcasts
are automatically generated. */
SwigType *bsmart = Copy(smart);
SwigType *rclsname = SwigType_typedef_resolve_all(clsname);
SwigType *rbname = SwigType_typedef_resolve_all(bname);
Replaceall(bsmart, rclsname, rbname);
Delete(rclsname);
Delete(rbname);
String *smartnamestr = SwigType_namestr(smart);
String *bsmartnamestr = SwigType_namestr(bsmart);
/* construct casting code */
String *convcode = NewStringf("\n *newmemory = SWIG_CAST_NEW_MEMORY;\n return (void *) new %s(*(%s *)$from);\n", bsmartnamestr, smartnamestr);
Delete(bsmartnamestr);
Delete(smartnamestr);
/* setup inheritance relationship between smart pointer templates */
SwigType_inherit(smart, bsmart, 0, convcode);
Delete(convcode);
Delete(bsmart);
Delete(smart);
} else {
Swig_error(Getfile(first), Getline(first), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, clsname);
}
}
if (!importmode) {
String *btype = Copy(bname);
SwigType_add_pointer(btype);
@ -296,6 +328,7 @@ class TypePass:private Dispatcher {
inclass = 0;
normalize = 0;
nsname = 0;
nssymname = 0;
classhash = Getattr(n, "classes");
emit_children(n);
normalize_list();
@ -415,6 +448,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 +572,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 +596,8 @@ class TypePass:private Dispatcher {
}
normalize = olist;
Delete(nssymname);
nssymname = oldnssymname;
Delete(nsname);
nsname = oldnsname;
return SWIG_OK;
@ -734,6 +775,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!
@ -750,7 +796,7 @@ class TypePass:private Dispatcher {
bool reset;
String *enumvalue = Getattr(c, "enumvalue");
if (GetFlag(c, "feature:ignore")) {
if (GetFlag(c, "feature:ignore") || !Getattr(c, "sym:name")) {
reset = enumvalue ? true : false;
previous_ignored = true;
} else {
@ -792,11 +838,15 @@ class TypePass:private Dispatcher {
value = name;
if (Strcmp(value, name) == 0) {
String *new_value;
if (((nsname) || (inclass)) && cparse_cplusplus) {
if ((nsname || inclass) && cparse_cplusplus) {
new_value = NewStringf("%s::%s", SwigType_namestr(Swig_symbol_qualified(n)), value);
} else {
new_value = NewString(value);
}
if ((nsname || inclass) && !cparse_cplusplus) {
String *cppvalue = NewStringf("%s::%s", SwigType_namestr(Swig_symbol_qualified(n)), value);
Setattr(n, "cppvalue", cppvalue); /* for target languages that always generate C++ code even when wrapping C code */
}
Setattr(n, "value", new_value);
Delete(new_value);
}