mirror of https://github.com/swig/swig
5032 lines
146 KiB
C++
5032 lines
146 KiB
C++
/* -----------------------------------------------------------------------------
|
|
* See the LICENSE file for information on copyright, usage and redistribution
|
|
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
|
|
*
|
|
* go.cxx
|
|
*
|
|
* Go language module for SWIG.
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
#include "swigmod.h"
|
|
#include "cparse.h"
|
|
#include <ctype.h>
|
|
|
|
class GO:public Language {
|
|
static const char *const usage;
|
|
|
|
// Go package name.
|
|
String *package;
|
|
// SWIG module name.
|
|
String *module;
|
|
// Flag for generating gccgo output.
|
|
bool gccgo_flag;
|
|
// Prefix to use with gccgo.
|
|
String *go_prefix;
|
|
// -fgo-prefix option.
|
|
String *prefix_option;
|
|
// -fgo-pkgpath option.
|
|
String *pkgpath_option;
|
|
// Whether to use a shared library.
|
|
bool use_shlib;
|
|
// Name of shared library to import.
|
|
String *soname;
|
|
// Size in bits of the Go type "int". 0 if not specified.
|
|
int intgo_type_size;
|
|
|
|
/* Output files */
|
|
File *f_c_begin;
|
|
File *f_go_begin;
|
|
File *f_gc_begin;
|
|
|
|
/* Output fragments */
|
|
File *f_c_runtime;
|
|
File *f_c_header;
|
|
File *f_c_wrappers;
|
|
File *f_c_init;
|
|
File *f_c_directors;
|
|
File *f_c_directors_h;
|
|
File *f_go_imports;
|
|
File *f_go_runtime;
|
|
File *f_go_header;
|
|
File *f_go_wrappers;
|
|
File *f_gc_runtime;
|
|
File *f_gc_header;
|
|
File *f_gc_wrappers;
|
|
|
|
// True if we imported a module.
|
|
bool saw_import;
|
|
// If not NULL, name of import package being processed.
|
|
String *imported_package;
|
|
// Build interface methods while handling a class. This is only
|
|
// non-NULL when we are handling methods.
|
|
String *interfaces;
|
|
// The class node while handling a class. This is only non-NULL
|
|
// when we are handling methods.
|
|
Node *class_node;
|
|
// The class name while handling a class. This is only non-NULL
|
|
// when we are handling methods. This is the name of the class as
|
|
// SWIG sees it.
|
|
String *class_name;
|
|
// The receiver name while handling a class. This is only non-NULL
|
|
// when we are handling methods. This is the name of the class
|
|
// as run through goCPointerType.
|
|
String *class_receiver;
|
|
// A hash table of method names that we have seen when processing a
|
|
// class. This lets us detect base class methods that we don't want
|
|
// to use.
|
|
Hash *class_methods;
|
|
// True when we are generating the wrapper functions for a variable.
|
|
bool making_variable_wrappers;
|
|
// True when working with a static member function.
|
|
bool is_static_member_function;
|
|
// A hash table of enum types that we have seen but which may not have
|
|
// been defined. The index is a SwigType.
|
|
Hash *undefined_enum_types;
|
|
// A hash table of types that we have seen but which may not have
|
|
// been defined. The index is a SwigType.
|
|
Hash *undefined_types;
|
|
// A hash table of classes which were defined. The index is a Go
|
|
// type name.
|
|
Hash *defined_types;
|
|
// A hash table of all the go_imports already imported. The index is a full
|
|
// import name e.g. '"runtime"' or '_ "runtime/cgo"' or 'sc "syscall"'.
|
|
Hash *go_imports;
|
|
|
|
public:
|
|
GO():package(NULL),
|
|
module(NULL),
|
|
gccgo_flag(false),
|
|
go_prefix(NULL),
|
|
prefix_option(NULL),
|
|
pkgpath_option(NULL),
|
|
use_shlib(false),
|
|
soname(NULL),
|
|
intgo_type_size(0),
|
|
f_c_begin(NULL),
|
|
f_go_begin(NULL),
|
|
f_gc_begin(NULL),
|
|
f_c_runtime(NULL),
|
|
f_c_header(NULL),
|
|
f_c_wrappers(NULL),
|
|
f_c_init(NULL),
|
|
f_c_directors(NULL),
|
|
f_c_directors_h(NULL),
|
|
f_go_imports(NULL),
|
|
f_go_runtime(NULL),
|
|
f_go_header(NULL),
|
|
f_go_wrappers(NULL),
|
|
f_gc_runtime(NULL),
|
|
f_gc_header(NULL),
|
|
f_gc_wrappers(NULL),
|
|
saw_import(false),
|
|
imported_package(NULL),
|
|
interfaces(NULL),
|
|
class_node(NULL),
|
|
class_name(NULL),
|
|
class_receiver(NULL),
|
|
class_methods(NULL),
|
|
making_variable_wrappers(false),
|
|
is_static_member_function(false),
|
|
undefined_enum_types(NULL),
|
|
undefined_types(NULL),
|
|
defined_types(NULL),
|
|
go_imports(NULL) {
|
|
director_multiple_inheritance = 1;
|
|
director_language = 1;
|
|
director_prot_ctor_code = NewString("_swig_gopanic(\"accessing abstract class or protected constructor\");");
|
|
}
|
|
|
|
private:
|
|
/* ------------------------------------------------------------
|
|
* main()
|
|
* ------------------------------------------------------------ */
|
|
virtual void main(int argc, char *argv[]) {
|
|
|
|
SWIG_library_directory("go");
|
|
bool display_help = false;
|
|
|
|
// Process command line options.
|
|
for (int i = 1; i < argc; i++) {
|
|
if (argv[i]) {
|
|
if (strcmp(argv[i], "-package") == 0) {
|
|
if (argv[i + 1]) {
|
|
package = NewString(argv[i + 1]);
|
|
Swig_mark_arg(i);
|
|
Swig_mark_arg(i + 1);
|
|
i++;
|
|
} else {
|
|
Swig_arg_error();
|
|
}
|
|
} else if (strcmp(argv[i], "-gccgo") == 0) {
|
|
Swig_mark_arg(i);
|
|
gccgo_flag = true;
|
|
} else if (strcmp(argv[i], "-go-prefix") == 0) {
|
|
if (argv[i + 1]) {
|
|
prefix_option = NewString(argv[i + 1]);
|
|
Swig_mark_arg(i);
|
|
Swig_mark_arg(i + 1);
|
|
i++;
|
|
} else {
|
|
Swig_arg_error();
|
|
}
|
|
} else if (strcmp(argv[i], "-go-pkgpath") == 0) {
|
|
if (argv[i + 1]) {
|
|
pkgpath_option = NewString(argv[i + 1]);
|
|
Swig_mark_arg(i);
|
|
Swig_mark_arg(i + 1);
|
|
i++;
|
|
} else {
|
|
Swig_arg_error();
|
|
}
|
|
} else if (strcmp(argv[i], "-use-shlib") == 0) {
|
|
Swig_mark_arg(i);
|
|
use_shlib = true;
|
|
} else if (strcmp(argv[i], "-soname") == 0) {
|
|
if (argv[i + 1]) {
|
|
soname = NewString(argv[i + 1]);
|
|
Swig_mark_arg(i);
|
|
Swig_mark_arg(i + 1);
|
|
i++;
|
|
} else {
|
|
Swig_arg_error();
|
|
}
|
|
} else if (strcmp(argv[i], "-longsize") == 0) {
|
|
// Ignore for backward compatibility.
|
|
if (argv[i + 1]) {
|
|
Swig_mark_arg(i);
|
|
Swig_mark_arg(i + 1);
|
|
++i;
|
|
} else {
|
|
Swig_arg_error();
|
|
}
|
|
} else if (strcmp(argv[i], "-intgosize") == 0) {
|
|
if (argv[i + 1]) {
|
|
intgo_type_size = atoi(argv[i + 1]);
|
|
if (intgo_type_size != 32 && intgo_type_size != 64) {
|
|
Printf(stderr, "-intgosize not 32 or 64\n");
|
|
Swig_arg_error();
|
|
}
|
|
Swig_mark_arg(i);
|
|
Swig_mark_arg(i + 1);
|
|
++i;
|
|
} else {
|
|
Swig_arg_error();
|
|
}
|
|
} else if (strcmp(argv[i], "-help") == 0) {
|
|
display_help = true;
|
|
Printf(stdout, "%s\n", usage);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (gccgo_flag && !pkgpath_option && !prefix_option) {
|
|
prefix_option = NewString("go");
|
|
}
|
|
|
|
// Add preprocessor symbol to parser.
|
|
Preprocessor_define("SWIGGO 1", 0);
|
|
|
|
if (gccgo_flag) {
|
|
Preprocessor_define("SWIGGO_GCCGO 1", 0);
|
|
}
|
|
|
|
// This test may be removed in the future, when we can assume that
|
|
// everybody has upgraded to Go 1.1. The code below is prepared
|
|
// for this test to simply be taken out.
|
|
if (intgo_type_size == 0 && !display_help) {
|
|
Printf(stderr, "SWIG -go: -intgosize option required but not specified\n");
|
|
SWIG_exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (intgo_type_size == 32) {
|
|
Preprocessor_define("SWIGGO_INTGO_SIZE 32", 0);
|
|
} else if (intgo_type_size == 64) {
|
|
Preprocessor_define("SWIGGO_INTGO_SIZE 64", 0);
|
|
} else {
|
|
Preprocessor_define("SWIGGO_INTGO_SIZE 0", 0);
|
|
}
|
|
|
|
// Add typemap definitions.
|
|
SWIG_typemap_lang("go");
|
|
SWIG_config_file("go.swg");
|
|
|
|
allow_overloading();
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------
|
|
* top()
|
|
*
|
|
* For 6g/8g, we are going to create the following files:
|
|
*
|
|
* 1) A .c or .cxx file compiled with gcc. This file will contain
|
|
* function wrappers. Each wrapper will take a pointer to a
|
|
* struct holding the arguments, unpack them, and call the real
|
|
* function.
|
|
*
|
|
* 2) A .go file which defines the Go form of all types, and which
|
|
* defines Go function wrappers. Each wrapper will call the C
|
|
* function wrapper in the second file.
|
|
*
|
|
* 3) A .c file compiled with 6c/8c. This file will define
|
|
* Go-callable C function wrappers. Each wrapper will use
|
|
* cgocall to call the function wrappers in the first file.
|
|
*
|
|
* When generating code for gccgo, we don't need the third file, and
|
|
* the function wrappers in the first file have a different form.
|
|
*
|
|
* --------------------------------------------------------------------- */
|
|
|
|
virtual int top(Node *n) {
|
|
Node *optionsnode = Getattr(Getattr(n, "module"), "options");
|
|
if (optionsnode) {
|
|
if (Getattr(optionsnode, "directors")) {
|
|
allow_directors();
|
|
}
|
|
if (Getattr(optionsnode, "dirprot")) {
|
|
allow_dirprot();
|
|
}
|
|
allow_allprotected(GetFlag(optionsnode, "allprotected"));
|
|
}
|
|
|
|
module = Getattr(n, "name");
|
|
if (!package) {
|
|
package = Copy(module);
|
|
}
|
|
if (!soname && use_shlib) {
|
|
soname = Copy(package);
|
|
Append(soname, ".so");
|
|
}
|
|
|
|
if (gccgo_flag) {
|
|
String *pref;
|
|
if (pkgpath_option) {
|
|
pref = pkgpath_option;
|
|
} else {
|
|
pref = prefix_option;
|
|
}
|
|
go_prefix = NewString("");
|
|
for (char *p = Char(pref); *p != '\0'; p++) {
|
|
if ((*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z') || (*p >= '0' && *p <= '9') || *p == '.' || *p == '$') {
|
|
Putc(*p, go_prefix);
|
|
} else {
|
|
Putc('_', go_prefix);
|
|
}
|
|
}
|
|
if (!pkgpath_option) {
|
|
Append(go_prefix, ".");
|
|
Append(go_prefix, package);
|
|
}
|
|
}
|
|
|
|
// Get filenames.
|
|
|
|
String *swig_filename = Getattr(n, "infile");
|
|
String *c_filename = Getattr(n, "outfile");
|
|
String *c_filename_h = Getattr(n, "outfile_h");
|
|
|
|
String *go_filename = NewString("");
|
|
Printf(go_filename, "%s%s.go", SWIG_output_directory(), module);
|
|
|
|
String *gc_filename = NULL;
|
|
if (!gccgo_flag) {
|
|
gc_filename = NewString("");
|
|
Printf(gc_filename, "%s%s_gc.c", SWIG_output_directory(), module);
|
|
}
|
|
|
|
// Open files.
|
|
|
|
f_c_begin = NewFile(c_filename, "w", SWIG_output_files());
|
|
if (!f_c_begin) {
|
|
FileErrorDisplay(c_filename);
|
|
SWIG_exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (directorsEnabled()) {
|
|
if (!c_filename_h) {
|
|
Printf(stderr, "Unable to determine outfile_h\n");
|
|
SWIG_exit(EXIT_FAILURE);
|
|
}
|
|
f_c_directors_h = NewFile(c_filename_h, "w", SWIG_output_files());
|
|
if (!f_c_directors_h) {
|
|
FileErrorDisplay(c_filename_h);
|
|
SWIG_exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
f_go_begin = NewFile(go_filename, "w", SWIG_output_files());
|
|
if (!f_go_begin) {
|
|
FileErrorDisplay(go_filename);
|
|
SWIG_exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (!gccgo_flag) {
|
|
f_gc_begin = NewFile(gc_filename, "w", SWIG_output_files());
|
|
if (!f_gc_begin) {
|
|
FileErrorDisplay(gc_filename);
|
|
SWIG_exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
f_c_runtime = NewString("");
|
|
f_c_header = NewString("");
|
|
f_c_wrappers = NewString("");
|
|
f_c_init = NewString("");
|
|
f_c_directors = NewString("");
|
|
f_go_imports = NewString("");
|
|
f_go_runtime = NewString("");
|
|
f_go_header = NewString("");
|
|
f_go_wrappers = NewString("");
|
|
if (!gccgo_flag) {
|
|
f_gc_runtime = NewString("");
|
|
f_gc_header = NewString("");
|
|
f_gc_wrappers = NewString("");
|
|
}
|
|
|
|
Swig_register_filebyname("begin", f_c_begin);
|
|
Swig_register_filebyname("runtime", f_c_runtime);
|
|
Swig_register_filebyname("header", f_c_header);
|
|
Swig_register_filebyname("wrapper", f_c_wrappers);
|
|
Swig_register_filebyname("init", f_c_init);
|
|
Swig_register_filebyname("director", f_c_directors);
|
|
Swig_register_filebyname("director_h", f_c_directors_h);
|
|
Swig_register_filebyname("go_begin", f_go_begin);
|
|
Swig_register_filebyname("go_imports", f_go_imports);
|
|
Swig_register_filebyname("go_runtime", f_go_runtime);
|
|
Swig_register_filebyname("go_header", f_go_header);
|
|
Swig_register_filebyname("go_wrapper", f_go_wrappers);
|
|
if (!gccgo_flag) {
|
|
Swig_register_filebyname("gc_begin", f_gc_begin);
|
|
Swig_register_filebyname("gc_runtime", f_gc_runtime);
|
|
Swig_register_filebyname("gc_header", f_gc_header);
|
|
Swig_register_filebyname("gc_wrapper", f_gc_wrappers);
|
|
}
|
|
|
|
Swig_banner(f_c_begin);
|
|
if (CPlusPlus) {
|
|
Printf(f_c_begin, "\n// source: %s\n\n", swig_filename);
|
|
} else {
|
|
Printf(f_c_begin, "\n/* source: %s */\n\n", swig_filename);
|
|
}
|
|
|
|
Printf(f_c_runtime, "#define SWIGMODULE %s\n", module);
|
|
if (gccgo_flag) {
|
|
Printf(f_c_runtime, "#define SWIGGO_PREFIX %s\n", go_prefix);
|
|
}
|
|
|
|
if (directorsEnabled()) {
|
|
Printf(f_c_runtime, "#define SWIG_DIRECTORS\n");
|
|
|
|
Swig_banner(f_c_directors_h);
|
|
Printf(f_c_directors_h, "\n// source: %s\n\n", swig_filename);
|
|
|
|
Printf(f_c_directors_h, "#ifndef SWIG_%s_WRAP_H_\n", module);
|
|
Printf(f_c_directors_h, "#define SWIG_%s_WRAP_H_\n\n", module);
|
|
|
|
Printf(f_c_directors, "\n// C++ director class methods.\n");
|
|
String *filename = Swig_file_filename(c_filename_h);
|
|
Printf(f_c_directors, "#include \"%s\"\n\n", filename);
|
|
Delete(filename);
|
|
}
|
|
|
|
Swig_banner(f_go_begin);
|
|
Printf(f_go_begin, "\n// source: %s\n", swig_filename);
|
|
|
|
if (!gccgo_flag && soname) {
|
|
Swig_banner(f_gc_begin);
|
|
Printf(f_gc_begin, "\n/* source: %s */\n\n", swig_filename);
|
|
Printf(f_gc_begin, "\n/* This file should be compiled with 6c/8c. */\n");
|
|
Printf(f_gc_begin, "#pragma dynimport _ _ \"%s\"\n", soname);
|
|
}
|
|
|
|
// Output module initialization code.
|
|
|
|
Printf(f_go_begin, "\npackage %s\n\n", package);
|
|
|
|
if (gccgo_flag) {
|
|
Printf(f_go_runtime, "func SwigCgocall()\n");
|
|
Printf(f_go_runtime, "func SwigCgocallDone()\n");
|
|
Printf(f_go_runtime, "func SwigCgocallBack()\n");
|
|
Printf(f_go_runtime, "func SwigCgocallBackDone()\n\n");
|
|
}
|
|
|
|
// All the C++ wrappers should be extern "C".
|
|
|
|
Printv(f_c_wrappers, "#ifdef __cplusplus\n", "extern \"C\" {\n", "#endif\n\n", NULL);
|
|
|
|
// Set up the hash table for types not defined by SWIG.
|
|
|
|
undefined_enum_types = NewHash();
|
|
undefined_types = NewHash();
|
|
defined_types = NewHash();
|
|
go_imports = NewHash();
|
|
|
|
// Emit code.
|
|
|
|
Language::top(n);
|
|
|
|
Delete(go_imports);
|
|
|
|
// Write out definitions for the types not defined by SWIG.
|
|
|
|
if (Len(undefined_enum_types) > 0)
|
|
Printv(f_go_wrappers, "\n", NULL);
|
|
for (Iterator p = First(undefined_enum_types); p.key; p = Next(p)) {
|
|
String *name = p.item;
|
|
Printv(f_go_wrappers, "type ", name, " int\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\n", NULL);
|
|
for (Iterator p = First(undefined_types); p.key; p = Next(p)) {
|
|
String *ty = goType(NULL, p.key);
|
|
if (!Getattr(defined_types, ty)) {
|
|
String *cp = goCPointerType(p.key, false);
|
|
if (!Getattr(defined_types, cp)) {
|
|
Printv(f_go_wrappers, "type ", cp, " uintptr\n", NULL);
|
|
Printv(f_go_wrappers, "type ", ty, " interface {\n", NULL);
|
|
Printv(f_go_wrappers, "\tSwigcptr() uintptr;\n", NULL);
|
|
Printv(f_go_wrappers, "}\n", NULL);
|
|
Printv(f_go_wrappers, "func (p ", cp, ") Swigcptr() uintptr {\n", NULL);
|
|
Printv(f_go_wrappers, "\treturn uintptr(p)\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
}
|
|
Delete(cp);
|
|
}
|
|
Delete(ty);
|
|
}
|
|
Delete(undefined_enum_types);
|
|
Delete(undefined_types);
|
|
Delete(defined_types);
|
|
|
|
/* Write and cleanup */
|
|
|
|
Dump(f_c_header, f_c_runtime);
|
|
|
|
if (directorsEnabled()) {
|
|
Printf(f_c_directors_h, "#endif\n");
|
|
Delete(f_c_directors_h);
|
|
f_c_directors_h = NULL;
|
|
|
|
Dump(f_c_directors, f_c_runtime);
|
|
Delete(f_c_directors);
|
|
f_c_directors = NULL;
|
|
}
|
|
|
|
// End the extern "C".
|
|
Printv(f_c_wrappers, "#ifdef __cplusplus\n", "}\n", "#endif\n\n", NULL);
|
|
|
|
Dump(f_c_runtime, f_c_begin);
|
|
Dump(f_c_wrappers, f_c_begin);
|
|
Dump(f_c_init, f_c_begin);
|
|
Dump(f_go_imports, f_go_begin);
|
|
Dump(f_go_header, f_go_begin);
|
|
Dump(f_go_runtime, f_go_begin);
|
|
Dump(f_go_wrappers, f_go_begin);
|
|
if (!gccgo_flag) {
|
|
Dump(f_gc_header, f_gc_begin);
|
|
Dump(f_gc_runtime, f_gc_begin);
|
|
Dump(f_gc_wrappers, f_gc_begin);
|
|
}
|
|
|
|
Delete(f_c_runtime);
|
|
Delete(f_c_header);
|
|
Delete(f_c_wrappers);
|
|
Delete(f_c_init);
|
|
Delete(f_go_imports);
|
|
Delete(f_go_runtime);
|
|
Delete(f_go_header);
|
|
Delete(f_go_wrappers);
|
|
if (!gccgo_flag) {
|
|
Delete(f_gc_runtime);
|
|
Delete(f_gc_header);
|
|
Delete(f_gc_wrappers);
|
|
}
|
|
|
|
Delete(f_c_begin);
|
|
Delete(f_go_begin);
|
|
if (!gccgo_flag) {
|
|
Delete(f_gc_begin);
|
|
}
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* importDirective()
|
|
*
|
|
* Handle a SWIG import statement by generating a Go import
|
|
* statement.
|
|
* ------------------------------------------------------------ */
|
|
|
|
virtual int importDirective(Node *n) {
|
|
String *hold_import = imported_package;
|
|
String *modname = Getattr(n, "module");
|
|
if (modname) {
|
|
if (!Getattr(go_imports, modname)) {
|
|
Setattr(go_imports, modname, modname);
|
|
Printv(f_go_imports, "import \"", modname, "\"\n", NULL);
|
|
}
|
|
imported_package = modname;
|
|
saw_import = true;
|
|
}
|
|
int r = Language::importDirective(n);
|
|
imported_package = hold_import;
|
|
return r;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* Language::insertDirective()
|
|
*
|
|
* If the section is go_imports, store them for later.
|
|
* ---------------------------------------------------------------------- */
|
|
virtual int insertDirective(Node *n) {
|
|
char *section = Char(Getattr(n, "section"));
|
|
if ((ImportMode && !Getattr(n, "generated")) ||
|
|
!section || (strcmp(section, "go_imports") != 0)) {
|
|
return Language::insertDirective(n);
|
|
}
|
|
|
|
char *code = Char(Getattr(n, "code"));
|
|
char *pch = strtok(code, ",");
|
|
while (pch != NULL) {
|
|
// Do not import same thing more than once.
|
|
if (!Getattr(go_imports, pch)) {
|
|
Setattr(go_imports, pch, pch);
|
|
Printv(f_go_imports, "import ", pch, "\n", NULL);
|
|
}
|
|
pch = strtok(NULL, ",");
|
|
}
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* functionWrapper()
|
|
*
|
|
* Implement a function.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
virtual int functionWrapper(Node *n) {
|
|
if (GetFlag(n, "feature:ignore")) {
|
|
return SWIG_OK;
|
|
}
|
|
|
|
// We don't need explicit calls.
|
|
if (GetFlag(n, "explicitcall")) {
|
|
return SWIG_OK;
|
|
}
|
|
|
|
String *name = Getattr(n, "sym:name");
|
|
String *nodetype = Getattr(n, "nodeType");
|
|
bool is_static = is_static_member_function || isStatic(n);
|
|
bool is_friend = isFriend(n);
|
|
bool is_ctor_dtor = false;
|
|
|
|
SwigType *result = Getattr(n, "type");
|
|
|
|
// For some reason SWIG changs the "type" value during the call to
|
|
// functionWrapper. We need to remember the type for possible
|
|
// overload processing.
|
|
Setattr(n, "go:type", Copy(result));
|
|
|
|
String *go_name;
|
|
|
|
String *r1 = NULL;
|
|
if (making_variable_wrappers) {
|
|
// Change the name of the variable setter and getter functions
|
|
// to be more Go like.
|
|
|
|
bool is_set = Strcmp(Char(name) + Len(name) - 4, "_set") == 0;
|
|
assert(is_set || Strcmp(Char(name) + Len(name) - 4, "_get") == 0);
|
|
|
|
// Start with Set or Get.
|
|
go_name = NewString(is_set ? "Set" : "Get");
|
|
|
|
// If this is a static variable, put in the class name,
|
|
// capitalized.
|
|
if (is_static && class_name) {
|
|
String *ccn = exportedName(class_name);
|
|
Append(go_name, ccn);
|
|
Delete(ccn);
|
|
}
|
|
|
|
// Add the rest of the name, capitalized, dropping the _set or
|
|
// _get.
|
|
String *c1 = removeClassname(name);
|
|
String *c2 = exportedName(c1);
|
|
char *p = Char(c2);
|
|
int len = Len(p);
|
|
for (int i = 0; i < len - 4; ++i) {
|
|
Putc(p[i], go_name);
|
|
}
|
|
Delete(c2);
|
|
Delete(c1);
|
|
|
|
if (!checkIgnoredParameters(n, go_name)) {
|
|
Delete(go_name);
|
|
return SWIG_NOWRAP;
|
|
}
|
|
} else if (Cmp(nodetype, "constructor") == 0) {
|
|
is_ctor_dtor = true;
|
|
|
|
// Change the name of a constructor to be more Go like. Change
|
|
// new_ to New, and capitalize the class name.
|
|
assert(Strncmp(name, "new_", 4) == 0);
|
|
String *c1 = NewString(Char(name) + 4);
|
|
String *c2 = exportedName(c1);
|
|
go_name = NewString("New");
|
|
Append(go_name, c2);
|
|
Delete(c2);
|
|
Delete(c1);
|
|
|
|
if (Swig_methodclass(n) && Swig_directorclass(n)
|
|
&& Strcmp(Char(Getattr(n, "wrap:action")), director_prot_ctor_code) != 0) {
|
|
// The core SWIG code skips the first parameter when
|
|
// generating the $nondirector_new string. Recreate the
|
|
// action in this case. But don't it if we are using the
|
|
// special code for an abstract class.
|
|
String *call = Swig_cppconstructor_call(getClassType(),
|
|
Getattr(n, "parms"));
|
|
SwigType *type = Copy(getClassType());
|
|
SwigType_add_pointer(type);
|
|
String *cres = Swig_cresult(type, Swig_cresult_name(), call);
|
|
Setattr(n, "wrap:action", cres);
|
|
}
|
|
} else if (Cmp(nodetype, "destructor") == 0) {
|
|
// No need to emit protected destructors.
|
|
if (!is_public(n)) {
|
|
return SWIG_OK;
|
|
}
|
|
|
|
is_ctor_dtor = true;
|
|
|
|
// Change the name of a destructor to be more Go like. Change
|
|
// delete_ to Delete and capitalize the class name.
|
|
assert(Strncmp(name, "delete_", 7) == 0);
|
|
String *c1 = NewString(Char(name) + 7);
|
|
String *c2 = exportedName(c1);
|
|
go_name = NewString("Delete");
|
|
Append(go_name, c2);
|
|
Delete(c2);
|
|
Delete(c1);
|
|
|
|
result = NewString("void");
|
|
r1 = result;
|
|
} else {
|
|
if (!checkFunctionVisibility(n, NULL)) {
|
|
return SWIG_OK;
|
|
}
|
|
|
|
go_name = buildGoName(name, is_static, is_friend);
|
|
|
|
if (!checkIgnoredParameters(n, go_name)) {
|
|
Delete(go_name);
|
|
return SWIG_NOWRAP;
|
|
}
|
|
}
|
|
|
|
String *overname = NULL;
|
|
if (Getattr(n, "sym:overloaded")) {
|
|
overname = Getattr(n, "sym:overname");
|
|
} else {
|
|
String *scope;
|
|
if (!class_name || is_static || is_ctor_dtor) {
|
|
scope = NULL;
|
|
} else {
|
|
scope = NewString("swiggoscope.");
|
|
Append(scope, class_name);
|
|
}
|
|
if (!checkNameConflict(go_name, n, scope)) {
|
|
Delete(go_name);
|
|
return SWIG_NOWRAP;
|
|
}
|
|
}
|
|
|
|
String *wname = Swig_name_wrapper(name);
|
|
if (overname) {
|
|
Append(wname, overname);
|
|
}
|
|
Setattr(n, "wrap:name", wname);
|
|
|
|
ParmList *parms = Getattr(n, "parms");
|
|
Setattr(n, "wrap:parms", parms);
|
|
|
|
int r = makeWrappers(n, name, go_name, overname, wname, NULL, parms, result, is_static);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
|
|
if (Getattr(n, "sym:overloaded") && !Getattr(n, "sym:nextSibling")) {
|
|
String *scope ;
|
|
if (!class_name || is_static || is_ctor_dtor) {
|
|
scope = NULL;
|
|
} else {
|
|
scope = NewString("swiggoscope.");
|
|
Append(scope, class_name);
|
|
}
|
|
if (!checkNameConflict(go_name, n, scope)) {
|
|
Delete(go_name);
|
|
return SWIG_NOWRAP;
|
|
}
|
|
|
|
String *receiver = class_receiver;
|
|
if (is_static || is_ctor_dtor) {
|
|
receiver = NULL;
|
|
}
|
|
r = makeDispatchFunction(n, go_name, receiver, is_static, NULL, false);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
Delete(wname);
|
|
Delete(go_name);
|
|
Delete(r1);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* staticmemberfunctionHandler()
|
|
*
|
|
* For some reason the language code removes the "storage" attribute
|
|
* for a static function before calling functionWrapper, which means
|
|
* that we have no way of knowing whether a function is static or
|
|
* not. That makes no sense in the Go context. Here we note that a
|
|
* function is static.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
int staticmemberfunctionHandler(Node *n) {
|
|
assert(!is_static_member_function);
|
|
is_static_member_function = true;
|
|
int r = Language::staticmemberfunctionHandler(n);
|
|
is_static_member_function = false;
|
|
return r;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* makeWrappers()
|
|
*
|
|
* Write out the various function wrappers.
|
|
* n: The function we are emitting.
|
|
* name: The function name.
|
|
* go_name: The name of the function in Go.
|
|
* overname: The overload string for overloaded function.
|
|
* wname: The SWIG wrapped name--the name of the C function.
|
|
* base: A list of the names of base classes, in the case where this
|
|
* is is a vritual method not defined in the current class.
|
|
* parms: The parameters.
|
|
* result: The result type.
|
|
* is_static: Whether this is a static method or member.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
int makeWrappers(Node *n, String *name, String *go_name, String *overname, String *wname, List *base, ParmList *parms, SwigType *result, bool is_static) {
|
|
|
|
assert(result);
|
|
|
|
bool needs_wrapper;
|
|
int r = goFunctionWrapper(n, name, go_name, overname, wname, base, parms, result, is_static, &needs_wrapper);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
|
|
if (!gccgo_flag) {
|
|
r = gcFunctionWrapper(n, name, go_name, overname, wname, parms, result, is_static, needs_wrapper);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
r = gccFunctionWrapper(n, base, wname, parms, result);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
} else {
|
|
r = gccgoFunctionWrapper(n, base, wname, parms, result);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
if (class_methods) {
|
|
Setattr(class_methods, Getattr(n, "name"), NewString(""));
|
|
}
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* goFunctionWrapper()
|
|
*
|
|
* Write out a function wrapper in Go. When not implementing a
|
|
* method, the actual code is all in C; here we just declare the C
|
|
* function. When implementing a method, we have to call the C
|
|
* function, because it will have a different name. If base is not
|
|
* NULL, then we are being called to forward a virtual method to a
|
|
* base class.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
int goFunctionWrapper(Node *n, String *name, String *go_name, String *overname, String *wname, List *base, ParmList *parms, SwigType *result, bool is_static, bool *p_needs_wrapper) {
|
|
Wrapper *dummy = NewWrapper();
|
|
emit_attach_parmmaps(parms, dummy);
|
|
Swig_typemap_attach_parms("default", parms, dummy);
|
|
Swig_typemap_attach_parms("gotype", parms, dummy);
|
|
int parm_count = emit_num_arguments(parms);
|
|
int required_count = emit_num_required(parms);
|
|
|
|
String *receiver = class_receiver;
|
|
if (receiver && is_static) {
|
|
receiver = NULL;
|
|
}
|
|
|
|
String *nodetype = Getattr(n, "nodeType");
|
|
bool is_constructor = Cmp(nodetype, "constructor") == 0;
|
|
bool is_destructor = Cmp(nodetype, "destructor") == 0;
|
|
if (is_constructor || is_destructor) {
|
|
assert(class_receiver);
|
|
assert(!base);
|
|
receiver = NULL;
|
|
}
|
|
|
|
bool add_to_interface = (interfaces && !is_constructor && !is_destructor && !is_static && !overname && checkFunctionVisibility(n, NULL));
|
|
|
|
bool needs_wrapper = (gccgo_flag || receiver || is_constructor || is_destructor || parm_count > required_count);
|
|
|
|
// See whether any of the function parameters are represented by
|
|
// interface values When calling the C++ code, we need to convert
|
|
// back to a uintptr.
|
|
if (!needs_wrapper) {
|
|
Parm *p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
String *ty = Getattr(p, "type");
|
|
if (goTypeIsInterface(p, ty)) {
|
|
needs_wrapper = true;
|
|
break;
|
|
}
|
|
p = nextParm(p);
|
|
}
|
|
}
|
|
if (goTypeIsInterface(n, result)) {
|
|
needs_wrapper = true;
|
|
}
|
|
|
|
*p_needs_wrapper = needs_wrapper;
|
|
|
|
// If this is a method, first declare the C function we will call.
|
|
// If we do not need a wrapper, then we will only be writing a
|
|
// declaration.
|
|
String *wrapper_name = NULL;
|
|
if (needs_wrapper) {
|
|
wrapper_name = buildGoWrapperName(name, overname);
|
|
|
|
if (gccgo_flag) {
|
|
Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "func ", wrapper_name, "(", NULL);
|
|
if (parm_count > required_count) {
|
|
Printv(f_go_wrappers, "int", NULL);
|
|
}
|
|
Parm *p = getParm(parms);
|
|
Swig_cparm_name(p, 0);
|
|
int i = 0;
|
|
if (is_destructor) {
|
|
if (parm_count > required_count) {
|
|
Printv(f_go_wrappers, ", ", NULL);
|
|
}
|
|
Printv(f_go_wrappers, "uintptr", NULL);
|
|
++i;
|
|
p = nextParm(p);
|
|
} else if (receiver && (base || !is_constructor)) {
|
|
if (parm_count > required_count) {
|
|
Printv(f_go_wrappers, ", ", NULL);
|
|
}
|
|
Printv(f_go_wrappers, receiver, NULL);
|
|
if (!base) {
|
|
++i;
|
|
p = nextParm(p);
|
|
}
|
|
}
|
|
for (; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
// Give the parameter a name we will use below.
|
|
Swig_cparm_name(p, i);
|
|
if (i > 0 || (base && receiver) || parm_count > required_count) {
|
|
Printv(f_go_wrappers, ", ", NULL);
|
|
}
|
|
String *tm = goWrapperType(p, Getattr(p, "type"), false);
|
|
Printv(f_go_wrappers, tm, NULL);
|
|
Delete(tm);
|
|
p = nextParm(p);
|
|
}
|
|
Printv(f_go_wrappers, ")", NULL);
|
|
if (is_constructor) {
|
|
Printv(f_go_wrappers, " ", class_receiver, NULL);
|
|
} else {
|
|
if (SwigType_type(result) != T_VOID) {
|
|
String *tm = goWrapperType(n, result, true);
|
|
Printv(f_go_wrappers, " ", tm, NULL);
|
|
Delete(tm);
|
|
}
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\n\n", NULL);
|
|
}
|
|
|
|
// Start defining the Go function.
|
|
|
|
if (!needs_wrapper && gccgo_flag) {
|
|
Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "func ", NULL);
|
|
|
|
Parm *p = parms;
|
|
int pi = 0;
|
|
|
|
// Add the receiver if this is a method.
|
|
if (receiver) {
|
|
Printv(f_go_wrappers, "(", NULL);
|
|
if (base && receiver) {
|
|
Printv(f_go_wrappers, "_swig_base", NULL);
|
|
} else {
|
|
Printv(f_go_wrappers, Getattr(p, "lname"), NULL);
|
|
p = nextParm(p);
|
|
++pi;
|
|
}
|
|
Printv(f_go_wrappers, " ", receiver, ") ", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, go_name, NULL);
|
|
if (overname) {
|
|
Printv(f_go_wrappers, overname, NULL);
|
|
}
|
|
Printv(f_go_wrappers, "(", NULL);
|
|
|
|
// If we are doing methods, add this function to the interface.
|
|
if (add_to_interface) {
|
|
Printv(interfaces, "\t", go_name, "(", NULL);
|
|
}
|
|
|
|
// Write out the parameters to both the function definition and
|
|
// the interface.
|
|
|
|
String *parm_print = NewString("");
|
|
|
|
for (; pi < parm_count; ++pi) {
|
|
p = getParm(p);
|
|
if (pi == 0 && is_destructor) {
|
|
String *cl = exportedName(class_name);
|
|
Printv(parm_print, Getattr(p, "lname"), " ", cl, NULL);
|
|
Delete(cl);
|
|
} else {
|
|
if (pi > (receiver && !base ? 1 : 0)) {
|
|
Printv(parm_print, ", ", NULL);
|
|
}
|
|
if (pi >= required_count) {
|
|
Printv(parm_print, "_swig_args ...interface{}", NULL);
|
|
break;
|
|
}
|
|
if (needs_wrapper) {
|
|
Printv(parm_print, Getattr(p, "lname"), " ", NULL);
|
|
}
|
|
String *tm = goType(p, Getattr(p, "type"));
|
|
Printv(parm_print, tm, NULL);
|
|
Delete(tm);
|
|
}
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(parm_print, ")", NULL);
|
|
|
|
// Write out the result type.
|
|
if (is_constructor) {
|
|
String *cl = exportedName(class_name);
|
|
Printv(parm_print, " ", cl, NULL);
|
|
Delete(cl);
|
|
} else {
|
|
if (SwigType_type(result) != T_VOID) {
|
|
String *tm = goType(n, result);
|
|
Printv(parm_print, " ", tm, NULL);
|
|
Delete(tm);
|
|
}
|
|
}
|
|
|
|
Printv(f_go_wrappers, parm_print, NULL);
|
|
if (add_to_interface) {
|
|
Printv(interfaces, parm_print, "\n", NULL);
|
|
}
|
|
|
|
// If this is a wrapper, we need to actually call the C function.
|
|
if (needs_wrapper) {
|
|
Printv(f_go_wrappers, " {\n", NULL);
|
|
|
|
if (parm_count > required_count) {
|
|
Parm *p = parms;
|
|
int i;
|
|
for (i = 0; i < required_count; ++i) {
|
|
p = getParm(p);
|
|
p = nextParm(p);
|
|
}
|
|
for (; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
String *tm = goType(p, Getattr(p, "type"));
|
|
Printv(f_go_wrappers, "\tvar ", Getattr(p, "lname"), " ", tm, "\n", NULL);
|
|
Printf(f_go_wrappers, "\tif len(_swig_args) > %d {\n", i - required_count);
|
|
Printf(f_go_wrappers, "\t\t%s = _swig_args[%d].(%s)\n", Getattr(p, "lname"), i - required_count, tm);
|
|
Printv(f_go_wrappers, "\t}\n", NULL);
|
|
Delete(tm);
|
|
p = nextParm(p);
|
|
}
|
|
}
|
|
|
|
if (gccgo_flag) {
|
|
if (!is_constructor) {
|
|
Printv(f_go_wrappers, "\tdefer SwigCgocallDone()\n", NULL);
|
|
Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL);
|
|
} else {
|
|
// For a constructor the wrapper function will return a
|
|
// uintptr but we will return an interface. We want to
|
|
// convert the uintptr to the interface after calling
|
|
// SwigCgocallDone, so that we don't try to allocate memory
|
|
// while the Go scheduler can't see us.
|
|
Printv(f_go_wrappers, "\tvar done bool\n", NULL);
|
|
Printv(f_go_wrappers, "\tdefer func() {\n", NULL);
|
|
Printv(f_go_wrappers, "\t\tif !done {\n", NULL);
|
|
Printv(f_go_wrappers, "\t\t\tSwigCgocallDone()\n", NULL);
|
|
Printv(f_go_wrappers, "\t\t}\n", NULL);
|
|
Printv(f_go_wrappers, "\t}()\n", NULL);
|
|
Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL);
|
|
}
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\t", NULL);
|
|
if (SwigType_type(result) != T_VOID) {
|
|
if (gccgo_flag && is_constructor) {
|
|
Printv(f_go_wrappers, "swig_r := ", NULL);
|
|
} else {
|
|
Printv(f_go_wrappers, "return ", NULL);
|
|
}
|
|
}
|
|
|
|
Printv(f_go_wrappers, wrapper_name, "(", NULL);
|
|
|
|
if (parm_count > required_count) {
|
|
Printv(f_go_wrappers, "len(_swig_args)", NULL);
|
|
}
|
|
|
|
if (base && receiver) {
|
|
if (parm_count > required_count) {
|
|
Printv(f_go_wrappers, ", ", NULL);
|
|
}
|
|
Printv(f_go_wrappers, "_swig_base", NULL);
|
|
}
|
|
|
|
Parm *p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
if (i > 0 || (base && receiver)
|
|
|| parm_count > required_count) {
|
|
Printv(f_go_wrappers, ", ", NULL);
|
|
}
|
|
Printv(f_go_wrappers, Getattr(p, "lname"), NULL);
|
|
|
|
// If this is a destructor, then the C function expects the
|
|
// C++ value, and we have the interface. We need to get the
|
|
// C++ value. The same is true for a type represented as an
|
|
// interface.
|
|
if ((i == 0 && is_destructor) || ((i > 0 || !receiver || base || is_constructor) && goTypeIsInterface(p, Getattr(p, "type")))) {
|
|
Printv(f_go_wrappers, ".Swigcptr()", NULL);
|
|
}
|
|
|
|
p = nextParm(p);
|
|
}
|
|
Printv(f_go_wrappers, ")\n", NULL);
|
|
|
|
if (gccgo_flag && is_constructor) {
|
|
Printv(f_go_wrappers, "\tSwigCgocallDone()\n", NULL);
|
|
Printv(f_go_wrappers, "\tdone = true\n", NULL);
|
|
Printv(f_go_wrappers, "\treturn swig_r\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "}\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\n", NULL);
|
|
|
|
Delete(wrapper_name);
|
|
DelWrapper(dummy);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* gcFunctionWrapper()
|
|
*
|
|
* This is used for 6g/8g, not for gccgo. Write out the function
|
|
* wrapper which will be compiled with 6c/8c.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
int gcFunctionWrapper(Node *n, String *name, String *go_name, String *overname, String *wname, ParmList *parms, SwigType *result, bool is_static, bool needs_wrapper) {
|
|
Wrapper *f = NewWrapper();
|
|
|
|
Printv(f->def, "#pragma dynimport ", wname, " ", wname, " \"\"\n", NULL);
|
|
Printv(f->def, "#pragma cgo_import_static ", wname, "\n", NULL);
|
|
Printv(f->def, "extern void (*", wname, ")(void*);\n", NULL);
|
|
Printv(f->def, "static void (*x", wname, ")(void*) = ", wname, ";\n", NULL);
|
|
Printv(f->def, "\n", NULL);
|
|
Printv(f->def, "void\n", NULL);
|
|
|
|
Wrapper *dummy = NewWrapper();
|
|
emit_attach_parmmaps(parms, dummy);
|
|
Swig_typemap_attach_parms("default", parms, dummy);
|
|
Swig_typemap_attach_parms("gosize", parms, dummy);
|
|
int parm_count = emit_num_arguments(parms);
|
|
int required_count = emit_num_required(parms);
|
|
|
|
String *parm_size = NewString("");
|
|
|
|
if (parm_count > required_count) {
|
|
Append(parm_size, "SWIG_PARM_SIZE");
|
|
}
|
|
|
|
if (class_receiver && !is_static) {
|
|
if (Len(parm_size) > 0) {
|
|
Append(parm_size, " + ");
|
|
}
|
|
Append(parm_size, "SWIG_PARM_SIZE");
|
|
}
|
|
|
|
Parm *p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
addGcTypeSize(p, Getattr(p, "type"), parm_size);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
if (SwigType_type(result) != T_VOID) {
|
|
addGcTypeSize(n, result, parm_size);
|
|
}
|
|
|
|
if (Len(parm_size) == 0) {
|
|
Append(parm_size, "1");
|
|
}
|
|
|
|
String *fn_name;
|
|
if (!needs_wrapper) {
|
|
fn_name = Copy(go_name);
|
|
if (overname) {
|
|
Append(fn_name, overname);
|
|
}
|
|
} else {
|
|
fn_name = buildGoWrapperName(name, overname);
|
|
}
|
|
|
|
// \xc2\xb7 is UTF-8 for U+00B7 which is Unicode 'Middle Dot'
|
|
Printv(f->def, "\xc2\xb7", fn_name, "(struct { uint8 x[", parm_size, "];} p)", NULL);
|
|
|
|
Delete(fn_name);
|
|
Delete(parm_size);
|
|
|
|
Printv(f->code, "{\n", NULL);
|
|
Printv(f->code, "\truntime\xc2\xb7" "cgocall(x", wname, ", &p);\n", NULL);
|
|
Printv(f->code, "}\n", NULL);
|
|
Printv(f->code, "\n", NULL);
|
|
|
|
Wrapper_print(f, f_gc_wrappers);
|
|
|
|
DelWrapper(f);
|
|
DelWrapper(dummy);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* getGcTypeSize()
|
|
*
|
|
* Return the size to use when passing a type from 6g/8g to 6c/8c.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *addGcTypeSize(Node *n, SwigType *type, String *orig) {
|
|
if (Len(orig) > 0) {
|
|
Append(orig, " + ");
|
|
}
|
|
|
|
String *go = goType(n, type);
|
|
if (Cmp(go, "string") == 0) {
|
|
// A string has a pointer and a length.
|
|
Append(orig, "(2 * SWIG_PARM_SIZE)");
|
|
} else if (Strncmp(go, "[]", 2) == 0) {
|
|
// A slice has a pointer, a length, and a capacity.
|
|
Append(orig, "(3 * SWIG_PARM_SIZE)");
|
|
} else if (Strcmp(go, "float64") == 0) {
|
|
Append(orig, "8");
|
|
} else if (Strcmp(go, "complex64") == 0) {
|
|
Append(orig, "8");
|
|
} else if (Strcmp(go, "complex128") == 0) {
|
|
Append(orig, "16");
|
|
} else {
|
|
Append(orig, "SWIG_PARM_SIZE");
|
|
}
|
|
|
|
return orig;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* gccFunctionWrapper()
|
|
*
|
|
* This is used for 6g/8g, not for gccgo. Write out the function
|
|
* wrapper which will be compiled with gcc. If the base parameter
|
|
* is not NULL, this is calls the base class method rather than
|
|
* executing the SWIG wrapper code.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
int gccFunctionWrapper(Node *n, List *base, String *wname, ParmList *parms, SwigType *result) {
|
|
Wrapper *f = NewWrapper();
|
|
|
|
Swig_save("gccFunctionWrapper", n, "parms", NULL);
|
|
|
|
Parm *base_parm = NULL;
|
|
if (base && !isStatic(n)) {
|
|
SwigType *base_type = Copy(getClassType());
|
|
SwigType_add_pointer(base_type);
|
|
base_parm = NewParm(base_type, NewString("arg1"), n);
|
|
set_nextSibling(base_parm, parms);
|
|
parms = base_parm;
|
|
}
|
|
|
|
emit_parameter_variables(parms, f);
|
|
emit_attach_parmmaps(parms, f);
|
|
int parm_count = emit_num_arguments(parms);
|
|
int required_count = emit_num_required(parms);
|
|
|
|
emit_return_variable(n, result, f);
|
|
|
|
// Start the function definition.
|
|
|
|
Printv(f->def, "void\n", wname, "(void *swig_v)\n", "{\n", NULL);
|
|
|
|
// The single function parameter is a pointer to the real argument
|
|
// values. Define the structure that it points to.
|
|
|
|
Printv(f->code, "\tstruct swigargs {\n", NULL);
|
|
|
|
if (parm_count > required_count) {
|
|
Printv(f->code, "\t\tintgo _swig_optargc;\n", NULL);
|
|
}
|
|
|
|
Parm *p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
String *ln = Getattr(p, "lname");
|
|
SwigType *pt = Getattr(p, "type");
|
|
String *ct = gcCTypeForGoValue(p, pt, ln);
|
|
Printv(f->code, "\t\t\t", ct, ";\n", NULL);
|
|
Delete(ct);
|
|
p = nextParm(p);
|
|
}
|
|
if (SwigType_type(result) != T_VOID) {
|
|
Printv(f->code, "\t\tlong : 0;\n", NULL);
|
|
String *ln = NewString(Swig_cresult_name());
|
|
String *ct = gcCTypeForGoValue(n, result, ln);
|
|
Delete(ln);
|
|
Printv(f->code, "\t\t", ct, ";\n", NULL);
|
|
Delete(ct);
|
|
}
|
|
Printv(f->code, "\t} *swig_a = (struct swigargs *) swig_v;\n", NULL);
|
|
|
|
Printv(f->code, "\n", NULL);
|
|
|
|
// Copy the input arguments out of the structure into the
|
|
// parameter variables.
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
|
|
String *tm = Getattr(p, "tmap:in");
|
|
if (!tm) {
|
|
Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument\n", SwigType_str(Getattr(p, "type"), 0));
|
|
} else {
|
|
String *ln = Getattr(p, "lname");
|
|
String *input = NewString("");
|
|
Printv(input, "swig_a->", ln, NULL);
|
|
Replaceall(tm, "$input", input);
|
|
Setattr(p, "emit:input", input);
|
|
if (i < required_count) {
|
|
Printv(f->code, "\t", tm, "\n", NULL);
|
|
} else {
|
|
Printf(f->code, "\tif (swig_a->_swig_optargc > %d) {\n", i - required_count);
|
|
Printv(f->code, "\t\t", tm, "\n", NULL);
|
|
Printv(f->code, "\t}\n", NULL);
|
|
}
|
|
}
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f->code, "\n", NULL);
|
|
|
|
// Do the real work of the function.
|
|
|
|
checkConstraints(parms, f);
|
|
|
|
emitGoAction(n, base, parms, result, f);
|
|
|
|
argout(parms, f);
|
|
|
|
cleanupFunction(n, f, parms);
|
|
|
|
Printv(f->code, "}\n", NULL);
|
|
|
|
Wrapper_print(f, f_c_wrappers);
|
|
|
|
Swig_restore(n);
|
|
|
|
DelWrapper(f);
|
|
Delete(base_parm);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* gccgoFunctionWrapper()
|
|
*
|
|
* This is used for gccgo, not 6g/8g. Write out the function
|
|
* wrapper which will be compiled with gcc. If the base parameter
|
|
* is not NULL, this is calls the base class method rather than
|
|
* executing the SWIG wrapper code.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
int gccgoFunctionWrapper(Node *n, List *base, String *wname, ParmList *parms, SwigType *result) {
|
|
Wrapper *f = NewWrapper();
|
|
|
|
Swig_save("gccgoFunctionWrapper", n, "parms", NULL);
|
|
|
|
Parm *base_parm = NULL;
|
|
if (base && !isStatic(n)) {
|
|
SwigType *base_type = Copy(getClassType());
|
|
SwigType_add_pointer(base_type);
|
|
base_parm = NewParm(base_type, NewString("arg1"), n);
|
|
set_nextSibling(base_parm, parms);
|
|
parms = base_parm;
|
|
}
|
|
|
|
emit_parameter_variables(parms, f);
|
|
emit_attach_parmmaps(parms, f);
|
|
int parm_count = emit_num_arguments(parms);
|
|
int required_count = emit_num_required(parms);
|
|
|
|
emit_return_variable(n, result, f);
|
|
|
|
// Start the function definition.
|
|
|
|
String *fnname = NewString("");
|
|
Printv(fnname, "go_", wname, "(", NULL);
|
|
|
|
if (parm_count > required_count) {
|
|
Printv(fnname, "intgo _swig_optargc", NULL);
|
|
}
|
|
|
|
Parm *p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
SwigType *pt = Copy(Getattr(p, "type"));
|
|
if (SwigType_isarray(pt)) {
|
|
SwigType_del_array(pt);
|
|
SwigType_add_pointer(pt);
|
|
}
|
|
String *pn = NewString("g");
|
|
Append(pn, Getattr(p, "lname"));
|
|
String *ct = gccgoCTypeForGoValue(p, pt, pn);
|
|
if (i > 0 || parm_count > required_count) {
|
|
Printv(fnname, ", ", NULL);
|
|
}
|
|
Printv(fnname, ct, NULL);
|
|
Delete(ct);
|
|
Delete(pn);
|
|
Delete(pt);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(fnname, ")", NULL);
|
|
|
|
String *fndef = NewString("");
|
|
if (SwigType_type(result) == T_VOID) {
|
|
Printv(fndef, "void ", fnname, NULL);
|
|
} else {
|
|
String *ct = gccgoCTypeForGoValue(n, result, fnname);
|
|
Printv(fndef, ct, NULL);
|
|
Delete(ct);
|
|
}
|
|
|
|
Printv(f->def, fndef, " __asm__(\"", go_prefix, "_", wname, "\");\n", NULL);
|
|
|
|
Printv(f->def, fndef, " {\n", NULL);
|
|
|
|
Delete(fnname);
|
|
Delete(fndef);
|
|
|
|
if (SwigType_type(result) != T_VOID) {
|
|
String *ln = NewString("go_result");
|
|
String *ct = gccgoCTypeForGoValue(n, result, ln);
|
|
Wrapper_add_local(f, "go_result", ct);
|
|
Delete(ct);
|
|
Delete(ln);
|
|
}
|
|
|
|
// Copy the parameters into the variables which hold their values,
|
|
// applying appropriate transformations.
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
|
|
String *tm = Getattr(p, "tmap:in");
|
|
if (!tm) {
|
|
Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number,
|
|
"Unable to use type %s as a function argument\n", SwigType_str(Getattr(p, "type"), 0));
|
|
} else {
|
|
String *ln = Getattr(p, "lname");
|
|
String *pn = NewString("g");
|
|
Append(pn, ln);
|
|
Replaceall(tm, "$input", pn);
|
|
Setattr(p, "emit:input", pn);
|
|
if (i < required_count) {
|
|
Printv(f->code, " ", tm, "\n", NULL);
|
|
} else {
|
|
Printf(f->code, " if (_swig_optargc > %d) {\n", i - required_count);
|
|
Printv(f->code, " ", tm, "\n", NULL);
|
|
Printv(f->code, " }\n", NULL);
|
|
}
|
|
}
|
|
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f->code, "\n", NULL);
|
|
|
|
// Do the real work of the function.
|
|
|
|
checkConstraints(parms, f);
|
|
|
|
emitGoAction(n, base, parms, result, f);
|
|
|
|
argout(parms, f);
|
|
|
|
cleanupFunction(n, f, parms);
|
|
|
|
if (SwigType_type(result) != T_VOID) {
|
|
Printv(f->code, " return go_result;\n", NULL);
|
|
}
|
|
|
|
Printv(f->code, "}\n", NULL);
|
|
|
|
Wrapper_print(f, f_c_wrappers);
|
|
|
|
Swig_restore(n);
|
|
|
|
DelWrapper(f);
|
|
Delete(base_parm);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
* checkConstraints()
|
|
*
|
|
* Check parameter constraints if any. This is used for the C/C++
|
|
* function. This assumes that each parameter has an "emit:input"
|
|
* property with the name to use to refer to that parameter.
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
void checkConstraints(ParmList *parms, Wrapper *f) {
|
|
Parm *p = parms;
|
|
while (p) {
|
|
String *tm = Getattr(p, "tmap:check");
|
|
if (!tm) {
|
|
p = nextSibling(p);
|
|
} else {
|
|
Replaceall(tm, "$input", Getattr(p, "emit:input"));
|
|
Printv(f->code, tm, "\n\n", NULL);
|
|
p = Getattr(p, "tmap:check:next");
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
* getGoAction()
|
|
*
|
|
* Get the action of the function. This is used for C/C++ function.
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
void emitGoAction(Node *n, List *base, ParmList *parms, SwigType *result, Wrapper *f) {
|
|
String *actioncode;
|
|
if (!base || isStatic(n)) {
|
|
Swig_director_emit_dynamic_cast(n, f);
|
|
actioncode = emit_action(n);
|
|
} else {
|
|
// Call the base class method.
|
|
actioncode = NewString("");
|
|
|
|
String *current = NewString("");
|
|
if (!gccgo_flag) {
|
|
Printv(current, "swig_a->", NULL);
|
|
}
|
|
Printv(current, Getattr(parms, "lname"), NULL);
|
|
|
|
int vc = 0;
|
|
for (Iterator bi = First(base); bi.item; bi = Next(bi)) {
|
|
Printf(actioncode, " %s *swig_b%d = (%s *)%s;\n", bi.item, vc, bi.item, current);
|
|
Delete(current);
|
|
current = NewString("");
|
|
Printf(current, "swig_b%d", vc);
|
|
++vc;
|
|
}
|
|
|
|
String *code = Copy(Getattr(n, "wrap:action"));
|
|
Replaceall(code, Getattr(parms, "lname"), current);
|
|
Printv(actioncode, code, "\n", NULL);
|
|
}
|
|
|
|
Swig_save("emitGoAction", n, "type", "tmap:out", NULL);
|
|
|
|
Setattr(n, "type", result);
|
|
|
|
String *tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode);
|
|
if (!tm) {
|
|
Swig_warning(WARN_TYPEMAP_OUT_UNDEF, input_file, line_number, "Unable to use return type %s\n", SwigType_str(result, 0));
|
|
} else {
|
|
if (!gccgo_flag) {
|
|
static const String *swig_a_result = NewStringf("swig_a->%s", Swig_cresult_name());
|
|
Replaceall(tm, "$result", swig_a_result);
|
|
} else {
|
|
Replaceall(tm, "$result", "go_result");
|
|
}
|
|
if (GetFlag(n, "feature:new")) {
|
|
Replaceall(tm, "$owner", "1");
|
|
} else {
|
|
Replaceall(tm, "$owner", "0");
|
|
}
|
|
Printv(f->code, tm, "\n", NULL);
|
|
Delete(tm);
|
|
}
|
|
|
|
Swig_restore(n);
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
* argout()
|
|
*
|
|
* Handle argument output code if any. This is used for the C/C++
|
|
* function. This assumes that each parameter has an "emit:input"
|
|
* property with the name to use to refer to that parameter.
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
void argout(ParmList *parms, Wrapper *f) {
|
|
Parm *p = parms;
|
|
while (p) {
|
|
String *tm = Getattr(p, "tmap:argout");
|
|
if (!tm) {
|
|
p = nextSibling(p);
|
|
} else {
|
|
Replaceall(tm, "$result", Swig_cresult_name());
|
|
Replaceall(tm, "$input", Getattr(p, "emit:input"));
|
|
Printv(f->code, tm, "\n", NULL);
|
|
p = Getattr(p, "tmap:argout:next");
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
* freearg()
|
|
*
|
|
* Handle argument cleanup code if any. This is used for the C/C++
|
|
* function. This assumes that each parameter has an "emit:input"
|
|
* property with the name to use to refer to that parameter.
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
String *freearg(ParmList *parms) {
|
|
String *ret = NewString("");
|
|
Parm *p = parms;
|
|
while (p) {
|
|
String *tm = Getattr(p, "tmap:freearg");
|
|
if (!tm) {
|
|
p = nextSibling(p);
|
|
} else {
|
|
Replaceall(tm, "$input", Getattr(p, "emit:input"));
|
|
Printv(ret, tm, "\n", NULL);
|
|
p = Getattr(p, "tmap:freearg:next");
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
* cleanupFunction()
|
|
*
|
|
* Final function cleanup code.
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
void cleanupFunction(Node *n, Wrapper *f, ParmList *parms) {
|
|
String *cleanup = freearg(parms);
|
|
Printv(f->code, cleanup, NULL);
|
|
|
|
if (GetFlag(n, "feature:new")) {
|
|
String *tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0);
|
|
if (tm) {
|
|
Replaceall(tm, "$source", Swig_cresult_name());
|
|
Printv(f->code, tm, "\n", NULL);
|
|
Delete(tm);
|
|
}
|
|
}
|
|
|
|
Replaceall(f->code, "$cleanup", cleanup);
|
|
Delete(cleanup);
|
|
|
|
Replaceall(f->code, "$symname", Getattr(n, "sym:name"));
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
* variableHandler()
|
|
*
|
|
* This exists just to set the making_variable_wrappers flag.
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
virtual int variableHandler(Node *n) {
|
|
assert(!making_variable_wrappers);
|
|
making_variable_wrappers = true;
|
|
int r = Language::variableHandler(n);
|
|
making_variable_wrappers = false;
|
|
return r;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
* constantWrapper()
|
|
*
|
|
* Product a const declaration.
|
|
* ------------------------------------------------------------------------ */
|
|
|
|
virtual int constantWrapper(Node *n) {
|
|
SwigType *type = Getattr(n, "type");
|
|
|
|
if (!SwigType_issimple(type) && SwigType_type(type) != T_STRING) {
|
|
return goComplexConstant(n, type);
|
|
}
|
|
|
|
if (Swig_storage_isstatic(n)) {
|
|
return goComplexConstant(n, type);
|
|
}
|
|
|
|
String *go_name = buildGoName(Getattr(n, "sym:name"), false, false);
|
|
|
|
String *tm = goType(n, type);
|
|
String *value = Getattr(n, "value");
|
|
|
|
String *copy = NULL;
|
|
if (SwigType_type(type) == T_BOOL) {
|
|
if (Cmp(value, "true") != 0 && Cmp(value, "false") != 0) {
|
|
return goComplexConstant(n, type);
|
|
}
|
|
} else if (SwigType_type(type) == T_STRING || SwigType_type(type) == T_CHAR) {
|
|
// Backslash sequences are somewhat different in Go and C/C++.
|
|
if (Strchr(value, '\\') != 0) {
|
|
return goComplexConstant(n, type);
|
|
}
|
|
} else {
|
|
// Accept a 0x prefix, and strip combinations of u and l
|
|
// suffixes. Otherwise accept digits, decimal point, and
|
|
// exponentiation. Treat anything else as too complicated to
|
|
// handle as a Go constant.
|
|
char *p = Char(value);
|
|
int len = strlen(p);
|
|
bool need_copy = false;
|
|
while (len > 0) {
|
|
char c = p[len - 1];
|
|
if (c != 'l' && c != 'L' && c != 'u' && c != 'U') {
|
|
break;
|
|
}
|
|
--len;
|
|
need_copy = true;
|
|
}
|
|
bool is_hex = false;
|
|
int i = 0;
|
|
if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
|
|
i = 2;
|
|
is_hex = true;
|
|
}
|
|
for (; i < len; ++i) {
|
|
switch (p[i]) {
|
|
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
|
|
break;
|
|
case 'a': case 'b': case 'c': case 'd': case 'f': case 'A': case 'B': case 'C': case 'D': case 'F':
|
|
if (!is_hex) {
|
|
return goComplexConstant(n, type);
|
|
}
|
|
break;
|
|
case '.': case 'e': case 'E': case '+': case '-':
|
|
break;
|
|
default:
|
|
return goComplexConstant(n, type);
|
|
}
|
|
}
|
|
if (need_copy) {
|
|
copy = Copy(value);
|
|
Replaceall(copy, p + len, "");
|
|
value = copy;
|
|
}
|
|
}
|
|
|
|
if (!checkNameConflict(go_name, n, NULL)) {
|
|
Delete(tm);
|
|
Delete(go_name);
|
|
Delete(copy);
|
|
return SWIG_NOWRAP;
|
|
}
|
|
|
|
Printv(f_go_wrappers, "const ", go_name, " ", tm, " = ", NULL);
|
|
if (SwigType_type(type) == T_STRING) {
|
|
Printv(f_go_wrappers, "\"", value, "\"", NULL);
|
|
} else if (SwigType_type(type) == T_CHAR) {
|
|
Printv(f_go_wrappers, "'", value, "'", NULL);
|
|
} else {
|
|
Printv(f_go_wrappers, value, NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\n", NULL);
|
|
|
|
Delete(tm);
|
|
Delete(go_name);
|
|
Delete(copy);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* enumDeclaration()
|
|
*
|
|
* A C++ enum type turns into a Named go int type.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
virtual int enumDeclaration(Node *n) {
|
|
String *name = goEnumName(n);
|
|
if (Strcmp(name, "int") != 0) {
|
|
if (!ImportMode || !imported_package) {
|
|
if (!checkNameConflict(name, n, NULL)) {
|
|
Delete(name);
|
|
return SWIG_NOWRAP;
|
|
}
|
|
Printv(f_go_wrappers, "type ", name, " int\n", NULL);
|
|
} else {
|
|
String *nw = NewString("");
|
|
Printv(nw, imported_package, ".", name, NULL);
|
|
Setattr(n, "go:enumname", nw);
|
|
}
|
|
}
|
|
Delete(name);
|
|
|
|
return Language::enumDeclaration(n);
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
* enumvalueDeclaration()
|
|
*
|
|
* Declare a single value of an enum type. We fetch the value by
|
|
* calling a C/C++ function.
|
|
* ------------------------------------------------------------------------ */
|
|
|
|
virtual int enumvalueDeclaration(Node *n) {
|
|
if (!is_public(n)) {
|
|
return SWIG_OK;
|
|
}
|
|
if (Getattr(parentNode(n), "unnamed")) {
|
|
Setattr(n, "type", NewString("int"));
|
|
} else {
|
|
Setattr(n, "type", Getattr(parentNode(n), "enumtype"));
|
|
}
|
|
return goComplexConstant(n, Getattr(n, "type"));
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
* goComplexConstant()
|
|
*
|
|
* Handle a const declaration for something which is not a Go constant.
|
|
* ------------------------------------------------------------------------ */
|
|
|
|
int goComplexConstant(Node *n, SwigType *type) {
|
|
String *symname = Getattr(n, "sym:name");
|
|
if (!symname) {
|
|
symname = Getattr(n, "name");
|
|
}
|
|
|
|
String *varname = buildGoName(symname, true, false);
|
|
|
|
if (!checkNameConflict(varname, n, NULL)) {
|
|
Delete(varname);
|
|
return SWIG_NOWRAP;
|
|
}
|
|
|
|
String *get = NewString("");
|
|
Printv(get, Swig_cresult_name(), " = ", NULL);
|
|
|
|
char quote;
|
|
if (Getattr(n, "wrappedasconstant")) {
|
|
quote = '\0';
|
|
} else if (SwigType_type(type) == T_CHAR) {
|
|
quote = '\'';
|
|
} else if (SwigType_type(type) == T_STRING) {
|
|
quote = '"';
|
|
} else {
|
|
quote = '\0';
|
|
}
|
|
|
|
if (quote != '\0') {
|
|
Printf(get, "%c", quote);
|
|
}
|
|
|
|
Printv(get, Getattr(n, "value"), NULL);
|
|
|
|
if (quote != '\0') {
|
|
Printf(get, "%c", quote);
|
|
}
|
|
|
|
Printv(get, ";\n", NULL);
|
|
Setattr(n, "wrap:action", get);
|
|
|
|
String *sname = Copy(symname);
|
|
if (class_name) {
|
|
Append(sname, "_");
|
|
Append(sname, class_name);
|
|
}
|
|
|
|
String *go_name = NewString("_swig_get");
|
|
if (class_name) {
|
|
Append(go_name, class_name);
|
|
Append(go_name, "_");
|
|
}
|
|
Append(go_name, sname);
|
|
|
|
String *wname = Swig_name_wrapper(sname);
|
|
Setattr(n, "wrap:name", wname);
|
|
|
|
int r = makeWrappers(n, sname, go_name, NULL, wname, NULL, NULL, type, true);
|
|
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
|
|
String *t = goType(n, type);
|
|
Printv(f_go_wrappers, "var ", varname, " ", t, " = ", go_name, "()\n", NULL);
|
|
|
|
Delete(varname);
|
|
Delete(t);
|
|
Delete(go_name);
|
|
Delete(sname);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* classHandler()
|
|
*
|
|
* For a C++ class, in Go we generate both a struct and an
|
|
* interface. The interface will declare all the class public
|
|
* methods. We will define all the methods on the struct, so that
|
|
* the struct meets the interface. We then expect users of the
|
|
* class to use the interface.
|
|
* ------------------------------------------------------------ */
|
|
|
|
virtual int classHandler(Node *n) {
|
|
class_node = n;
|
|
|
|
List *baselist = Getattr(n, "bases");
|
|
bool has_base_classes = baselist && Len(baselist) > 0;
|
|
|
|
String *name = Getattr(n, "sym:name");
|
|
|
|
String *go_name = exportedName(name);
|
|
|
|
if (!checkNameConflict(go_name, n, NULL)) {
|
|
Delete(go_name);
|
|
SetFlag(n, "go:conflict");
|
|
return SWIG_NOWRAP;
|
|
}
|
|
|
|
String *go_type_name = goCPointerType(Getattr(n, "classtypeobj"), true);
|
|
|
|
class_name = name;
|
|
class_receiver = go_type_name;
|
|
class_methods = NewHash();
|
|
|
|
int isdir = GetFlag(n, "feature:director");
|
|
int isnodir = GetFlag(n, "feature:nodirector");
|
|
bool is_director = isdir && !isnodir;
|
|
|
|
Printv(f_go_wrappers, "type ", go_type_name, " uintptr\n\n", NULL);
|
|
|
|
// A method to return the pointer to the C++ class. This is used
|
|
// by generated code to convert between the interface and the C++
|
|
// value.
|
|
Printv(f_go_wrappers, "func (p ", go_type_name, ") Swigcptr() uintptr {\n", NULL);
|
|
Printv(f_go_wrappers, "\treturn (uintptr)(p)\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
// A method used as a marker for the class, to avoid invalid
|
|
// interface conversions when using multiple inheritance.
|
|
Printv(f_go_wrappers, "func (p ", go_type_name, ") SwigIs", go_name, "() {\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
if (is_director) {
|
|
// Return the interface passed to the NewDirector function.
|
|
Printv(f_go_wrappers, "func (p ", go_type_name, ") DirectorInterface() interface{} {\n", NULL);
|
|
Printv(f_go_wrappers, "\treturn nil\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
}
|
|
|
|
// We have seen a definition for this type.
|
|
Setattr(defined_types, go_name, go_name);
|
|
Setattr(defined_types, go_type_name, go_type_name);
|
|
|
|
interfaces = NewString("");
|
|
|
|
int r = Language::classHandler(n);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
|
|
if (has_base_classes) {
|
|
// For each method defined in a base class but not defined in
|
|
// this class, we need to define the method in this class. We
|
|
// can't use anonymous field inheritance because it works
|
|
// differently in Go and in C++.
|
|
|
|
Hash *local = NewHash();
|
|
for (Node *ni = Getattr(n, "firstChild"); ni; ni = nextSibling(ni)) {
|
|
|
|
if (!is_public(ni)) {
|
|
continue;
|
|
}
|
|
|
|
String *type = Getattr(ni, "nodeType");
|
|
if (Cmp(type, "constructor") == 0 || Cmp(type, "destructor") == 0) {
|
|
continue;
|
|
}
|
|
|
|
String *cname = Getattr(ni, "sym:name");
|
|
if (!cname) {
|
|
cname = Getattr(ni, "name");
|
|
}
|
|
if (cname) {
|
|
Setattr(local, cname, NewString(""));
|
|
}
|
|
}
|
|
|
|
for (Iterator b = First(baselist); b.item; b = Next(b)) {
|
|
List *bases = NewList();
|
|
Append(bases, Getattr(b.item, "classtype"));
|
|
int r = addBase(n, b.item, bases, local);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
Delete(bases);
|
|
}
|
|
|
|
Delete(local);
|
|
|
|
Hash *parents = NewHash();
|
|
addFirstBaseInterface(n, parents, baselist);
|
|
int r = addExtraBaseInterfaces(n, parents, baselist);
|
|
Delete(parents);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
Printv(f_go_wrappers, "type ", go_name, " interface {\n", NULL);
|
|
Printv(f_go_wrappers, "\tSwigcptr() uintptr\n", NULL);
|
|
Printv(f_go_wrappers, "\tSwigIs", go_name, "()\n", NULL);
|
|
|
|
if (is_director) {
|
|
Printv(f_go_wrappers, "\tDirectorInterface() interface{}\n", NULL);
|
|
}
|
|
|
|
Append(f_go_wrappers, interfaces);
|
|
Printf(f_go_wrappers, "}\n\n", NULL);
|
|
Delete(interfaces);
|
|
|
|
interfaces = NULL;
|
|
class_name = NULL;
|
|
class_receiver = NULL;
|
|
class_node = NULL;
|
|
Delete(class_methods);
|
|
class_methods = NULL;
|
|
|
|
Delete(go_type_name);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* addBase()
|
|
*
|
|
* Implement methods and members defined in a parent class for a
|
|
* child class.
|
|
* ------------------------------------------------------------ */
|
|
|
|
int addBase(Node *n, Node *base, List *bases, Hash *local) {
|
|
if (GetFlag(base, "feature:ignore")) {
|
|
return SWIG_OK;
|
|
}
|
|
|
|
for (Node *ni = Getattr(base, "firstChild"); ni; ni = nextSibling(ni)) {
|
|
|
|
if (GetFlag(ni, "feature:ignore")) {
|
|
continue;
|
|
}
|
|
|
|
if (!is_public(ni)) {
|
|
continue;
|
|
}
|
|
|
|
String *type = Getattr(ni, "nodeType");
|
|
if (Strcmp(type, "constructor") == 0 || Strcmp(type, "destructor") == 0 || Strcmp(type, "enum") == 0 || Strcmp(type, "using") == 0 || Strcmp(type, "classforward") == 0 || Strcmp(type, "template") == 0) {
|
|
continue;
|
|
}
|
|
String *storage = Getattr(ni, "storage");
|
|
if (storage && (Strcmp(storage, "typedef") == 0 || Strcmp(storage, "friend") == 0)) {
|
|
continue;
|
|
}
|
|
|
|
String *mname = Getattr(ni, "sym:name");
|
|
if (!mname) {
|
|
continue;
|
|
}
|
|
|
|
String *lname = Getattr(ni, "name");
|
|
if (Getattr(class_methods, lname)) {
|
|
continue;
|
|
}
|
|
if (Getattr(local, lname)) {
|
|
continue;
|
|
}
|
|
Setattr(local, lname, NewString(""));
|
|
|
|
String *ty = NewString(Getattr(ni, "type"));
|
|
SwigType_push(ty, Getattr(ni, "decl"));
|
|
String *fullty = SwigType_typedef_resolve_all(ty);
|
|
bool is_function = SwigType_isfunction(fullty) ? true : false;
|
|
Delete(ty);
|
|
Delete(fullty);
|
|
|
|
if (is_function) {
|
|
int r = goBaseMethod(n, bases, ni);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
|
|
if (Getattr(ni, "sym:overloaded")) {
|
|
for (Node *on = Getattr(ni, "sym:nextSibling"); on; on = Getattr(on, "sym:nextSibling")) {
|
|
r = goBaseMethod(n, bases, on);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
String *receiver = class_receiver;
|
|
bool is_static = isStatic(ni);
|
|
if (is_static) {
|
|
receiver = NULL;
|
|
}
|
|
String *go_name = buildGoName(Getattr(ni, "sym:name"), is_static, false);
|
|
r = makeDispatchFunction(ni, go_name, receiver, is_static, NULL, false);
|
|
Delete(go_name);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
}
|
|
} else {
|
|
int r = goBaseVariable(n, bases, ni);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
}
|
|
}
|
|
|
|
List *baselist = Getattr(base, "bases");
|
|
if (baselist && Len(baselist) > 0) {
|
|
for (Iterator b = First(baselist); b.item; b = Next(b)) {
|
|
List *nb = Copy(bases);
|
|
Append(nb, Getattr(b.item, "classtype"));
|
|
int r = addBase(n, b.item, nb, local);
|
|
Delete(nb);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
}
|
|
}
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* goBaseMethod()
|
|
*
|
|
* Implement a method defined in a parent class for a child class.
|
|
* ------------------------------------------------------------ */
|
|
|
|
int goBaseMethod(Node *method_class, List *bases, Node *method) {
|
|
String *symname = Getattr(method, "sym:name");
|
|
if (!validIdentifier(symname)) {
|
|
return SWIG_OK;
|
|
}
|
|
|
|
String *name = NewString("");
|
|
Printv(name, Getattr(method_class, "sym:name"), "_", symname, NULL);
|
|
|
|
bool is_static = isStatic(method);
|
|
|
|
String *go_name = buildGoName(name, is_static, false);
|
|
|
|
String *overname = NULL;
|
|
if (Getattr(method, "sym:overloaded")) {
|
|
overname = Getattr(method, "sym:overname");
|
|
}
|
|
String *wname = Swig_name_wrapper(name);
|
|
if (overname) {
|
|
Append(wname, overname);
|
|
}
|
|
|
|
String *result = NewString(Getattr(method, "type"));
|
|
SwigType_push(result, Getattr(method, "decl"));
|
|
if (SwigType_isqualifier(result)) {
|
|
Delete(SwigType_pop(result));
|
|
}
|
|
Delete(SwigType_pop_function(result));
|
|
|
|
// If the base method is imported, wrap:action may not be set.
|
|
Swig_save("goBaseMethod", method, "wrap:name", "wrap:action", "parms", NULL);
|
|
Setattr(method, "wrap:name", wname);
|
|
if (!Getattr(method, "wrap:action")) {
|
|
if (!is_static) {
|
|
Swig_MethodToFunction(method, getNSpace(), getClassType(), (Getattr(method, "template") ? SmartPointer : Extend | SmartPointer), NULL, false);
|
|
// Remove any self parameter that was just added.
|
|
ParmList *parms = Getattr(method, "parms");
|
|
if (parms && Getattr(parms, "self")) {
|
|
parms = CopyParmList(nextSibling(parms));
|
|
Setattr(method, "parms", parms);
|
|
}
|
|
} else {
|
|
String *call = Swig_cfunction_call(Getattr(method, "name"), Getattr(method, "parms"));
|
|
Setattr(method, "wrap:action", Swig_cresult(Getattr(method, "type"), Swig_cresult_name(), call));
|
|
}
|
|
}
|
|
|
|
int r = makeWrappers(method, name, go_name, overname, wname, bases, Getattr(method, "parms"), result, is_static);
|
|
|
|
Swig_restore(method);
|
|
|
|
Delete(result);
|
|
Delete(go_name);
|
|
Delete(name);
|
|
|
|
return r;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* goBaseVariable()
|
|
*
|
|
* Add accessors for a member variable defined in a parent class for
|
|
* a child class.
|
|
* ------------------------------------------------------------ */
|
|
|
|
int goBaseVariable(Node *var_class, List *bases, Node *var) {
|
|
if (isStatic(var)) {
|
|
return SWIG_OK;
|
|
}
|
|
|
|
String *var_name = buildGoName(Getattr(var, "sym:name"), false, false);
|
|
|
|
Swig_save("goBaseVariable", var, "type", "wrap:action", NULL);
|
|
|
|
// For a pointer type we apparently have to wrap in the decl.
|
|
SwigType *var_type = NewString(Getattr(var, "type"));
|
|
SwigType_push(var_type, Getattr(var, "decl"));
|
|
Setattr(var, "type", var_type);
|
|
|
|
SwigType *vt = Copy(var_type);
|
|
if (SwigType_isclass(vt)) {
|
|
SwigType_add_pointer(vt);
|
|
}
|
|
|
|
int flags = Extend | SmartPointer | use_naturalvar_mode(var);
|
|
if (isNonVirtualProtectedAccess(var)) {
|
|
flags |= CWRAP_ALL_PROTECTED_ACCESS;
|
|
}
|
|
|
|
String *mname = Swig_name_member(getNSpace(), Getattr(var_class, "sym:name"), var_name);
|
|
|
|
if (is_assignable(var)) {
|
|
for (Iterator ki = First(var); ki.key; ki = Next(ki)) {
|
|
if (Strncmp(ki.key, "tmap:", 5) == 0) {
|
|
Delattr(var, ki.key);
|
|
}
|
|
}
|
|
Swig_save("goBaseVariableSet", var, "name", "sym:name", "type", NULL);
|
|
|
|
String *mname_set = NewString("Set");
|
|
Append(mname_set, mname);
|
|
|
|
String *go_name = NewString("Set");
|
|
Append(go_name, var_name);
|
|
|
|
Swig_MembersetToFunction(var, class_name, flags);
|
|
|
|
String *wname = Swig_name_wrapper(mname_set);
|
|
ParmList *parms = NewParm(vt, var_name, var);
|
|
String *result = NewString("void");
|
|
int r = makeWrappers(var, mname_set, go_name, NULL, wname, bases, parms, result, false);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
Delete(wname);
|
|
Delete(parms);
|
|
Delete(result);
|
|
Delete(go_name);
|
|
Delete(mname_set);
|
|
|
|
Swig_restore(var);
|
|
for (Iterator ki = First(var); ki.key; ki = Next(ki)) {
|
|
if (Strncmp(ki.key, "tmap:", 5) == 0) {
|
|
Delattr(var, ki.key);
|
|
}
|
|
}
|
|
}
|
|
|
|
Swig_MembergetToFunction(var, class_name, flags);
|
|
|
|
String *mname_get = NewString("Get");
|
|
Append(mname_get, mname);
|
|
|
|
String *go_name = NewString("Get");
|
|
Append(go_name, var_name);
|
|
|
|
String *wname = Swig_name_wrapper(mname_get);
|
|
|
|
int r = makeWrappers(var, mname_get, go_name, NULL, wname, bases, NULL, vt, false);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
|
|
Delete(wname);
|
|
Delete(mname_get);
|
|
Delete(go_name);
|
|
Delete(mname);
|
|
Delete(var_name);
|
|
Delete(var_type);
|
|
Delete(vt);
|
|
|
|
Swig_restore(var);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* addFirstBaseInterface()
|
|
*
|
|
* When a C++ class uses multiple inheritance, we can use the C++
|
|
* pointer for the first base class but not for any subsequent base
|
|
* classes. However, the Go interface will match the interface for
|
|
* all the base classes. To avoid accidentally treating a class as
|
|
* a pointer to a base class other than the first one, we use an
|
|
* isClassname method. This function adds those methods as
|
|
* required.
|
|
*
|
|
* For convenience when using multiple inheritance, we also add
|
|
* functions to retrieve the base class pointers.
|
|
* ------------------------------------------------------------ */
|
|
|
|
void addFirstBaseInterface(Node *n, Hash *parents, List *bases) {
|
|
if (!bases || Len(bases) == 0) {
|
|
return;
|
|
}
|
|
Iterator b = First(bases);
|
|
if (!GetFlag(b.item, "feature:ignore")) {
|
|
String *go_name = buildGoName(Getattr(n, "sym:name"), false, false);
|
|
String *go_type_name = goCPointerType(Getattr(n, "classtypeobj"), true);
|
|
String *go_base_name = exportedName(Getattr(b.item, "sym:name"));
|
|
String *go_base_type = goType(n, Getattr(b.item, "classtypeobj"));
|
|
String *go_base_type_name = goCPointerType(Getattr(b.item, "classtypeobj"), true);
|
|
|
|
Printv(f_go_wrappers, "func (p ", go_type_name, ") SwigIs", go_base_name, "() {\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
Printv(interfaces, "\tSwigIs", go_base_name, "()\n", NULL);
|
|
|
|
Printv(f_go_wrappers, "func (p ", go_type_name, ") SwigGet", go_base_name, "() ", go_base_type, " {\n", NULL);
|
|
Printv(f_go_wrappers, "\treturn ", go_base_type_name, "(p.Swigcptr())\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
Printv(interfaces, "\tSwigGet", go_base_name, "() ", go_base_type, "\n", NULL);
|
|
|
|
Setattr(parents, go_base_name, NewString(""));
|
|
|
|
Delete(go_name);
|
|
Delete(go_type_name);
|
|
Delete(go_base_type);
|
|
Delete(go_base_type_name);
|
|
}
|
|
|
|
addFirstBaseInterface(n, parents, Getattr(b.item, "bases"));
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* addExtraBaseInterfaces()
|
|
*
|
|
* Add functions to retrieve the base class pointers for all base
|
|
* classes other than the first.
|
|
* ------------------------------------------------------------ */
|
|
|
|
int addExtraBaseInterfaces(Node *n, Hash *parents, List *bases) {
|
|
Iterator b = First(bases);
|
|
|
|
Node *fb = b.item;
|
|
|
|
for (b = Next(b); b.item; b = Next(b)) {
|
|
if (GetFlag(b.item, "feature:ignore")) {
|
|
continue;
|
|
}
|
|
|
|
String *go_base_name = exportedName(Getattr(b.item, "sym:name"));
|
|
|
|
Swig_save("addExtraBaseInterface", n, "wrap:action", "wrap:name", "wrap:parms", NULL);
|
|
|
|
SwigType *type = Copy(Getattr(n, "classtypeobj"));
|
|
SwigType_add_pointer(type);
|
|
Parm *parm = NewParm(type, "self", n);
|
|
Setattr(n, "wrap:parms", parm);
|
|
|
|
String *pn = Swig_cparm_name(parm, 0);
|
|
String *action = NewString("");
|
|
Printv(action, Swig_cresult_name(), " = (", Getattr(b.item, "classtype"), "*)", pn, ";", NULL);
|
|
Delete(pn);
|
|
|
|
Setattr(n, "wrap:action", action);
|
|
|
|
String *name = Copy(class_name);
|
|
Append(name, "_SwigGet");
|
|
Append(name, go_base_name);
|
|
|
|
String *go_name = NewString("SwigGet");
|
|
String *c1 = exportedName(go_base_name);
|
|
Append(go_name, c1);
|
|
Delete(c1);
|
|
|
|
String *wname = Swig_name_wrapper(name);
|
|
Setattr(n, "wrap:name", wname);
|
|
|
|
SwigType *result = Copy(Getattr(b.item, "classtypeobj"));
|
|
SwigType_add_pointer(result);
|
|
|
|
int r = makeWrappers(n, name, go_name, NULL, wname, NULL, parm, result,
|
|
false);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
|
|
Swig_restore(n);
|
|
|
|
Setattr(parents, go_base_name, NewString(""));
|
|
|
|
Delete(go_name);
|
|
Delete(type);
|
|
Delete(parm);
|
|
Delete(action);
|
|
Delete(result);
|
|
|
|
String *ns = NewString("");
|
|
addParentExtraBaseInterfaces(n, parents, b.item, false, ns);
|
|
Delete(ns);
|
|
}
|
|
|
|
if (!GetFlag(fb, "feature:ignore")) {
|
|
String *ns = NewString("");
|
|
addParentExtraBaseInterfaces(n, parents, fb, true, ns);
|
|
Delete(ns);
|
|
}
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* addParentExtraBaseInterfaces()
|
|
*
|
|
* Add functions to retrieve the base class pointers for all base
|
|
* classes of parents other than the first base class at each level.
|
|
* ------------------------------------------------------------ */
|
|
|
|
void addParentExtraBaseInterfaces(Node *n, Hash *parents, Node *base, bool is_base_first, String *sofar) {
|
|
List *baselist = Getattr(base, "bases");
|
|
if (!baselist || Len(baselist) == 0) {
|
|
return;
|
|
}
|
|
|
|
String *go_this_base_name = exportedName(Getattr(base, "sym:name"));
|
|
|
|
String *sf = NewString("");
|
|
Printv(sf, sofar, ".SwigGet", go_this_base_name, "()", NULL);
|
|
|
|
Iterator b = First(baselist);
|
|
|
|
if (is_base_first) {
|
|
if (!b.item) {
|
|
return;
|
|
}
|
|
if (!GetFlag(b.item, "feature:ignore")) {
|
|
addParentExtraBaseInterfaces(n, parents, b.item, true, sf);
|
|
}
|
|
|
|
b = Next(b);
|
|
}
|
|
|
|
String *go_name = buildGoName(Getattr(n, "sym:name"), false, false);
|
|
String *go_type_name = goCPointerType(Getattr(n, "classtypeobj"), true);
|
|
|
|
for (; b.item; b = Next(b)) {
|
|
if (GetFlag(b.item, "feature:ignore")) {
|
|
continue;
|
|
}
|
|
|
|
String *go_base_name = exportedName(Getattr(b.item, "sym:name"));
|
|
|
|
if (!Getattr(parents, go_base_name)) {
|
|
Printv(f_go_wrappers, "func (p ", go_type_name, ") SwigGet", go_base_name, "() ", go_base_name, " {\n", NULL);
|
|
Printv(f_go_wrappers, "\treturn p", sf, ".SwigGet", go_base_name, "()\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
Printv(interfaces, "\tSwigGet", go_base_name, "() ", go_base_name, "\n", NULL);
|
|
|
|
addParentExtraBaseInterfaces(n, parents, b.item, false, sf);
|
|
|
|
Setattr(parents, go_base_name, NewString(""));
|
|
}
|
|
}
|
|
|
|
Delete(go_name);
|
|
Delete(go_type_name);
|
|
Delete(go_this_base_name);
|
|
Delete(sf);
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* classDirectorInit
|
|
*
|
|
* Add support for a director class.
|
|
*
|
|
* Virtual inheritance is different in Go and C++. We implement
|
|
* director classes by defining a new function in Go,
|
|
* NewDirectorClassname, which takes a empty interface value and
|
|
* creates an instance of a new child class. The new child class
|
|
* refers all methods back to Go. The Go code checks whether the
|
|
* value passed to NewDirectorClassname implements that method; if
|
|
* it does, it calls it, otherwise it calls back into C++.
|
|
* ------------------------------------------------------------ */
|
|
|
|
int classDirectorInit(Node *n) {
|
|
// Because we use a different function to handle inheritance in
|
|
// Go, ordinary creations of the object should not create a
|
|
// director object.
|
|
Delete(director_ctor_code);
|
|
director_ctor_code = NewString("$nondirector_new");
|
|
|
|
class_node = n;
|
|
|
|
String *name = Getattr(n, "sym:name");
|
|
|
|
assert(!class_name);
|
|
class_name = name;
|
|
|
|
String *go_name = exportedName(name);
|
|
|
|
String *go_type_name = goCPointerType(Getattr(n, "classtypeobj"), true);
|
|
|
|
assert(!class_receiver);
|
|
class_receiver = go_type_name;
|
|
|
|
String *director_struct_name = NewString("_swig_Director");
|
|
Append(director_struct_name, go_name);
|
|
|
|
String *cxx_director_name = NewString("SwigDirector_");
|
|
Append(cxx_director_name, name);
|
|
|
|
// The Go type of the director class.
|
|
Printv(f_go_wrappers, "type ", director_struct_name, " struct {\n", NULL);
|
|
Printv(f_go_wrappers, "\t", go_type_name, "\n", NULL);
|
|
Printv(f_go_wrappers, "\tv interface{}\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
Printv(f_go_wrappers, "func (p *", director_struct_name, ") Swigcptr() uintptr {\n", NULL);
|
|
Printv(f_go_wrappers, "\treturn p.", go_type_name, ".Swigcptr()\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
Printv(f_go_wrappers, "func (p *", director_struct_name, ") SwigIs", go_name, "() {\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
Printv(f_go_wrappers, "func (p *", director_struct_name, ") DirectorInterface() interface{} {\n", NULL);
|
|
Printv(f_go_wrappers, "\treturn p.v\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
// Start defining the director class.
|
|
Printv(f_c_directors_h, "class ", cxx_director_name, " : public ", Getattr(n, "classtype"), "\n", NULL);
|
|
Printv(f_c_directors_h, "{\n", NULL);
|
|
Printv(f_c_directors_h, " public:\n", NULL);
|
|
|
|
Delete(director_struct_name);
|
|
Delete(cxx_director_name);
|
|
|
|
class_methods = NewHash();
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* classDirectorConstructor
|
|
*
|
|
* Emit a constructor for a director class.
|
|
* ------------------------------------------------------------ */
|
|
|
|
int classDirectorConstructor(Node *n) {
|
|
bool is_ignored = GetFlag(n, "feature:ignore") ? true : false;
|
|
|
|
String *name = Getattr(n, "sym:name");
|
|
if (!name) {
|
|
assert(is_ignored);
|
|
name = Getattr(n, "name");
|
|
}
|
|
|
|
String *overname = NULL;
|
|
if (Getattr(n, "sym:overloaded")) {
|
|
overname = Getattr(n, "sym:overname");
|
|
}
|
|
|
|
String *go_name = exportedName(name);
|
|
|
|
ParmList *parms = Getattr(n, "parms");
|
|
Setattr(n, "wrap:parms", parms);
|
|
|
|
String *cn = exportedName(Getattr(parentNode(n), "sym:name"));
|
|
|
|
String *go_type_name = goCPointerType(Getattr(parentNode(n), "classtypeobj"), true);
|
|
|
|
String *director_struct_name = NewString("_swig_Director");
|
|
Append(director_struct_name, cn);
|
|
|
|
String *fn_name = NewString("_swig_NewDirector");
|
|
Append(fn_name, cn);
|
|
Append(fn_name, go_name);
|
|
|
|
if (!overname && !is_ignored) {
|
|
if (!checkNameConflict(fn_name, n, NULL)) {
|
|
return SWIG_NOWRAP;
|
|
}
|
|
}
|
|
|
|
String *wname = Swig_name_wrapper(fn_name);
|
|
|
|
if (overname) {
|
|
Append(wname, overname);
|
|
}
|
|
Setattr(n, "wrap:name", wname);
|
|
|
|
bool is_static = isStatic(n);
|
|
|
|
Wrapper *dummy = NewWrapper();
|
|
emit_attach_parmmaps(parms, dummy);
|
|
DelWrapper(dummy);
|
|
|
|
Swig_typemap_attach_parms("gotype", parms, NULL);
|
|
int parm_count = emit_num_arguments(parms);
|
|
|
|
String *func_name = NewString("NewDirector");
|
|
Append(func_name, go_name);
|
|
|
|
String *func_with_over_name = Copy(func_name);
|
|
if (overname) {
|
|
Append(func_with_over_name, overname);
|
|
}
|
|
|
|
SwigType *first_type = NewString("void");
|
|
SwigType_add_pointer(first_type);
|
|
Parm *first_parm = NewParm(first_type, "swig_p", n);
|
|
set_nextSibling(first_parm, parms);
|
|
Setattr(first_parm, "lname", "p");
|
|
|
|
Parm *p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
Swig_cparm_name(p, i);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
if (!is_ignored) {
|
|
// Declare the C++ wrapper.
|
|
|
|
if (gccgo_flag) {
|
|
Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "func ", fn_name, NULL);
|
|
if (overname) {
|
|
Printv(f_go_wrappers, overname, NULL);
|
|
}
|
|
Printv(f_go_wrappers, "(*", director_struct_name, NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
String *tm = goType(p, Getattr(p, "type"));
|
|
Printv(f_go_wrappers, ", ", tm, NULL);
|
|
Delete(tm);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ") ", go_type_name, "\n\n", NULL);
|
|
|
|
Printv(f_go_wrappers, "func ", func_with_over_name, "(v interface{}", NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
// Set the lname parameter.
|
|
Printv(f_go_wrappers, ", ", Getattr(p, "lname"), " ", NULL);
|
|
String *tm = goType(p, Getattr(p, "type"));
|
|
Printv(f_go_wrappers, tm, NULL);
|
|
Delete(tm);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ") ", cn, " {\n", NULL);
|
|
|
|
Printv(f_go_wrappers, "\tp := &", director_struct_name, "{0, v}\n", NULL);
|
|
|
|
if (gccgo_flag) {
|
|
Printv(f_go_wrappers, "\tdefer SwigCgocallDone()\n", NULL);
|
|
Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\tp.", class_receiver, " = ", fn_name, NULL);
|
|
if (overname) {
|
|
Printv(f_go_wrappers, overname, NULL);
|
|
}
|
|
Printv(f_go_wrappers, "(p", NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
Printv(f_go_wrappers, ", ", Getattr(p, "lname"), NULL);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ")\n", NULL);
|
|
Printv(f_go_wrappers, "\treturn p\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
SwigType *result = Copy(Getattr(parentNode(n), "classtypeobj"));
|
|
SwigType_add_pointer(result);
|
|
|
|
Swig_save("classDirectorConstructor", n, "wrap:name", "wrap:action", NULL);
|
|
|
|
Setattr(n, "wrap:name", Swig_name_wrapper(name));
|
|
|
|
String *action = NewString("");
|
|
Printv(action, Swig_cresult_name(), " = new SwigDirector_", class_name, "(", NULL);
|
|
String *pname = Swig_cparm_name(NULL, 0);
|
|
Printv(action, pname, NULL);
|
|
Delete(pname);
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
String *pname = Swig_cparm_name(NULL, i + 1);
|
|
Printv(action, ", ", NULL);
|
|
if (SwigType_isreference(Getattr(p, "type"))) {
|
|
Printv(action, "*", NULL);
|
|
}
|
|
Printv(action, pname, NULL);
|
|
Delete(pname);
|
|
p = nextParm(p);
|
|
}
|
|
Printv(action, ");", NULL);
|
|
Setattr(n, "wrap:action", action);
|
|
|
|
if (!gccgo_flag) {
|
|
int r = gcFunctionWrapper(n, fn_name, fn_name, overname, wname,
|
|
first_parm, result, is_static, false);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
r = gccFunctionWrapper(n, NULL, wname, first_parm, result);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
} else {
|
|
int r = gccgoFunctionWrapper(n, NULL, wname, first_parm, result);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
Swig_restore(n);
|
|
|
|
Delete(result);
|
|
}
|
|
|
|
String *cxx_director_name = NewString("SwigDirector_");
|
|
Append(cxx_director_name, class_name);
|
|
|
|
String *decl = Swig_method_decl(NULL, Getattr(n, "decl"),
|
|
cxx_director_name, first_parm, 0, 0);
|
|
Printv(f_c_directors_h, " ", decl, ";\n", NULL);
|
|
Delete(decl);
|
|
|
|
decl = Swig_method_decl(NULL, Getattr(n, "decl"), cxx_director_name, first_parm, 0, 0);
|
|
Printv(f_c_directors, cxx_director_name, "::", decl, "\n", NULL);
|
|
Delete(decl);
|
|
|
|
Printv(f_c_directors, " : ", Getattr(parentNode(n), "classtype"), "(", NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
if (i > 0) {
|
|
Printv(f_c_directors, ", ", NULL);
|
|
}
|
|
String *pn = Getattr(p, "name");
|
|
assert(pn);
|
|
Printv(f_c_directors, pn, NULL);
|
|
p = nextParm(p);
|
|
}
|
|
Printv(f_c_directors, "),\n", NULL);
|
|
Printv(f_c_directors, " go_val(swig_p)\n", NULL);
|
|
Printv(f_c_directors, "{ }\n\n", NULL);
|
|
|
|
if (Getattr(n, "sym:overloaded") && !Getattr(n, "sym:nextSibling")) {
|
|
int r = makeDispatchFunction(n, func_name, cn, is_static, Getattr(parentNode(n), "classtypeobj"), false);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
Delete(cxx_director_name);
|
|
Delete(go_name);
|
|
Delete(cn);
|
|
Delete(go_type_name);
|
|
Delete(director_struct_name);
|
|
Delete(fn_name);
|
|
Delete(func_name);
|
|
Delete(func_with_over_name);
|
|
Delete(wname);
|
|
Delete(first_type);
|
|
Delete(first_parm);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* classDirectorDestructor
|
|
*
|
|
* Emit a destructor for a director class.
|
|
* ------------------------------------------------------------ */
|
|
|
|
int classDirectorDestructor(Node *n) {
|
|
if (!is_public(n)) {
|
|
return SWIG_OK;
|
|
}
|
|
|
|
bool is_ignored = GetFlag(n, "feature:ignore") ? true : false;
|
|
|
|
if (!is_ignored) {
|
|
String *fnname = NewString("DeleteDirector");
|
|
String *c1 = exportedName(class_name);
|
|
Append(fnname, c1);
|
|
Delete(c1);
|
|
|
|
String *wname = Swig_name_wrapper(fnname);
|
|
|
|
Setattr(n, "wrap:name", fnname);
|
|
|
|
Swig_DestructorToFunction(n, getNSpace(), getClassType(), CPlusPlus, Extend);
|
|
|
|
ParmList *parms = Getattr(n, "parms");
|
|
Setattr(n, "wrap:parms", parms);
|
|
|
|
String *result = NewString("void");
|
|
int r = makeWrappers(n, fnname, fnname, NULL, wname, NULL, parms, result, isStatic(n));
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
|
|
Delete(result);
|
|
Delete(fnname);
|
|
Delete(wname);
|
|
}
|
|
|
|
// Generate the destructor for the C++ director class. Since the
|
|
// Go code is keeping a pointer to the C++ object, we need to call
|
|
// back to the Go code to let it know that the C++ object is gone.
|
|
|
|
String *wname = NewString("_swiggo_wrap_DeleteDirector_");
|
|
Append(wname, class_name);
|
|
|
|
String *go_name = NewString("Swiggo_DeleteDirector_");
|
|
Append(go_name, class_name);
|
|
|
|
String *cn = exportedName(class_name);
|
|
|
|
String *director_struct_name = NewString("_swig_Director");
|
|
Append(director_struct_name, cn);
|
|
|
|
Printv(f_c_directors_h, " virtual ~SwigDirector_", class_name, "()", NULL);
|
|
|
|
String *throws = buildThrow(n);
|
|
if (throws) {
|
|
Printv(f_c_directors_h, " ", throws, NULL);
|
|
}
|
|
|
|
Printv(f_c_directors_h, ";\n", NULL);
|
|
|
|
if (!is_ignored) {
|
|
if (!gccgo_flag) {
|
|
Printv(f_c_directors, "extern \"C\" void ", wname, "(void*, int);\n", NULL);
|
|
} else {
|
|
Printv(f_c_directors, "extern \"C\" void ", wname, "(void*) __asm__(\"", go_prefix, ".", go_name, "\");\n", NULL);
|
|
}
|
|
}
|
|
|
|
Printv(f_c_directors, "SwigDirector_", class_name, "::~SwigDirector_", class_name, "()", NULL);
|
|
|
|
if (throws) {
|
|
Printv(f_c_directors, " ", throws, NULL);
|
|
Delete(throws);
|
|
}
|
|
|
|
Printv(f_c_directors, "\n", NULL);
|
|
Printv(f_c_directors, "{\n", NULL);
|
|
|
|
if (!is_ignored) {
|
|
if (!gccgo_flag) {
|
|
Printv(f_c_directors, " struct { void *p; } a;\n", NULL);
|
|
Printv(f_c_directors, " a.p = go_val;\n", NULL);
|
|
Printv(f_c_directors, " crosscall2(", wname, ", &a, (int) sizeof a);\n", NULL);
|
|
|
|
Printv(f_gc_wrappers, "#pragma dynexport ", wname, " ", wname, "\n", NULL);
|
|
Printv(f_gc_wrappers, "#pragma cgo_export_static ", wname, " ", wname, "\n", NULL);
|
|
Printv(f_gc_wrappers, "#pragma textflag 7\n", NULL);
|
|
Printv(f_gc_wrappers, "extern void \xc2\xb7", go_name, "();\n", NULL);
|
|
Printv(f_gc_wrappers, "void\n", NULL);
|
|
Printv(f_gc_wrappers, wname, "(void *a, int32 n)\n", NULL);
|
|
Printv(f_gc_wrappers, "{\n", NULL);
|
|
Printv(f_gc_wrappers, "\truntime\xc2\xb7" "cgocallback(\xc2\xb7", go_name, ", a, n);\n", NULL);
|
|
Printv(f_gc_wrappers, "}\n\n", NULL);
|
|
} else {
|
|
Printv(f_c_directors, " ", wname, "(go_val);\n", NULL);
|
|
}
|
|
}
|
|
|
|
Printv(f_c_directors, "}\n\n", NULL);
|
|
|
|
if (!is_ignored) {
|
|
Printv(f_go_wrappers, "func ", go_name, "(p *", director_struct_name, ") {\n", NULL);
|
|
Printv(f_go_wrappers, "\tp.", class_receiver, " = 0\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
}
|
|
|
|
Delete(wname);
|
|
Delete(go_name);
|
|
Delete(cn);
|
|
Delete(director_struct_name);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* classDirectorMethod
|
|
*
|
|
* Emit a method for a director class, plus its overloads.
|
|
* ------------------------------------------------------------ */
|
|
|
|
int classDirectorMethod(Node *n, Node *parent, String *super) {
|
|
bool is_ignored = GetFlag(n, "feature:ignore") ? true : false;
|
|
|
|
// We don't need explicit calls.
|
|
if (GetFlag(n, "explicitcall")) {
|
|
return SWIG_OK;
|
|
}
|
|
|
|
String *name = Getattr(n, "sym:name");
|
|
if (!name) {
|
|
assert(is_ignored);
|
|
name = Getattr(n, "name");
|
|
}
|
|
|
|
bool overloaded = Getattr(n, "sym:overloaded") && !Getattr(n, "explicitcallnode");
|
|
if (!overloaded) {
|
|
int r = oneClassDirectorMethod(n, parent, super);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
} else {
|
|
// Handle overloaded methods here, because otherwise we will
|
|
// reject them in the class_methods hash table. We need to use
|
|
// class_methods so that we correctly handle cases where a
|
|
// function in one class hides a function of the same name in a
|
|
// parent class.
|
|
if (!Getattr(class_methods, name)) {
|
|
for (Node *on = Getattr(n, "sym:overloaded"); on; on = Getattr(on, "sym:nextSibling")) {
|
|
// Swig_overload_rank expects wrap:name and wrap:parms to be
|
|
// set.
|
|
String *wn = Swig_name_wrapper(Getattr(on, "sym:name"));
|
|
Append(wn, Getattr(on, "sym:overname"));
|
|
Setattr(on, "wrap:name", wn);
|
|
Delete(wn);
|
|
Setattr(on, "wrap:parms", Getattr(on, "parms"));
|
|
}
|
|
}
|
|
|
|
int r = oneClassDirectorMethod(n, parent, super);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
|
|
if (!Getattr(n, "sym:nextSibling"))
|
|
{
|
|
// Last overloaded function
|
|
Node *on = Getattr(n, "sym:overloaded");
|
|
bool is_static = isStatic(on);
|
|
|
|
String *cn = exportedName(Getattr(parent, "sym:name"));
|
|
String *go_name = buildGoName(name, is_static, false);
|
|
|
|
String *director_struct_name = NewString("_swig_Director");
|
|
Append(director_struct_name, cn);
|
|
|
|
int r = makeDispatchFunction(on, go_name, director_struct_name, is_static, director_struct_name, false);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
|
|
if (!GetFlag(n, "abstract")) {
|
|
String *go_upcall = NewString("Director");
|
|
Append(go_upcall, cn);
|
|
Append(go_upcall, go_name);
|
|
r = makeDispatchFunction(on, go_upcall, director_struct_name, is_static, director_struct_name, true);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
Delete(go_upcall);
|
|
}
|
|
|
|
Delete(director_struct_name);
|
|
Delete(go_name);
|
|
Delete(cn);
|
|
}
|
|
}
|
|
Setattr(class_methods, name, NewString(""));
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* oneClassDirectorMethod
|
|
*
|
|
* Emit a method for a director class.
|
|
* ------------------------------------------------------------ */
|
|
|
|
int oneClassDirectorMethod(Node *n, Node *parent, String *super) {
|
|
String *symname = Getattr(n, "sym:name");
|
|
if (!checkFunctionVisibility(n, parent)) {
|
|
return SWIG_OK;
|
|
}
|
|
|
|
bool is_ignored = GetFlag(n, "feature:ignore") ? true : false;
|
|
bool is_pure_virtual = (Cmp(Getattr(n, "storage"), "virtual") == 0 && Cmp(Getattr(n, "value"), "0") == 0);
|
|
|
|
String *name = Getattr(n, "sym:name");
|
|
if (!name) {
|
|
assert(is_ignored);
|
|
name = Getattr(n, "name");
|
|
}
|
|
|
|
String *overname = NULL;
|
|
if (Getattr(n, "sym:overloaded")) {
|
|
overname = Getattr(n, "sym:overname");
|
|
}
|
|
|
|
String *cn = exportedName(Getattr(parent, "sym:name"));
|
|
|
|
String *go_type_name = goCPointerType(Getattr(parent, "classtypeobj"), true);
|
|
|
|
String *director_struct_name = NewString("_swig_Director");
|
|
Append(director_struct_name, cn);
|
|
|
|
bool is_static = isStatic(n);
|
|
|
|
String *go_name = buildGoName(name, is_static, false);
|
|
|
|
ParmList *parms = Getattr(n, "parms");
|
|
Setattr(n, "wrap:parms", parms);
|
|
|
|
Wrapper *dummy = NewWrapper();
|
|
emit_attach_parmmaps(parms, dummy);
|
|
DelWrapper(dummy);
|
|
|
|
Swig_typemap_attach_parms("gotype", parms, NULL);
|
|
int parm_count = emit_num_arguments(parms);
|
|
|
|
SwigType *result = Getattr(n, "type");
|
|
|
|
// Save the type for overload processing.
|
|
Setattr(n, "go:type", result);
|
|
|
|
String *interface_name = NewString("_swig_DirectorInterface");
|
|
Append(interface_name, cn);
|
|
Append(interface_name, go_name);
|
|
if (overname) {
|
|
Append(interface_name, overname);
|
|
}
|
|
|
|
String *callback_name = Copy(director_struct_name);
|
|
Append(callback_name, "_callback_");
|
|
Append(callback_name, name);
|
|
Replace(callback_name, "_swig", "Swig", DOH_REPLACE_FIRST);
|
|
if (overname) {
|
|
Append(callback_name, overname);
|
|
}
|
|
|
|
String *callback_wname = Swig_name_wrapper(callback_name);
|
|
|
|
String *upcall_name = Copy(director_struct_name);
|
|
Append(upcall_name, "_upcall_");
|
|
Append(upcall_name, go_name);
|
|
|
|
String *upcall_wname = Swig_name_wrapper(upcall_name);
|
|
if (overname) {
|
|
Append(upcall_wname, overname);
|
|
}
|
|
|
|
String *upcall_gc_name = buildGoWrapperName(upcall_name, overname);
|
|
|
|
String *go_with_over_name = Copy(go_name);
|
|
if (overname) {
|
|
Append(go_with_over_name, overname);
|
|
}
|
|
|
|
Parm *p = 0;
|
|
Wrapper *w = NewWrapper();
|
|
|
|
Swig_director_parms_fixup(parms);
|
|
|
|
Swig_typemap_attach_parms("directorin", parms, w);
|
|
Swig_typemap_attach_parms("directorargout", parms, w);
|
|
|
|
if (!is_ignored) {
|
|
// We use an interface to see if this method is defined in Go.
|
|
Printv(f_go_wrappers, "type ", interface_name, " interface {\n", NULL);
|
|
Printv(f_go_wrappers, "\t", go_with_over_name, "(", NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
if (i > 0) {
|
|
Printv(f_go_wrappers, ", ", NULL);
|
|
}
|
|
String *tm = goType(p, Getattr(p, "type"));
|
|
Printv(f_go_wrappers, tm, NULL);
|
|
Delete(tm);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ")", NULL);
|
|
|
|
if (SwigType_type(result) != T_VOID) {
|
|
String *tm = goType(n, result);
|
|
Printv(f_go_wrappers, " ", tm, NULL);
|
|
Delete(tm);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
if (!GetFlag(n, "abstract")) {
|
|
// Declare the upcall function, which calls the method on the
|
|
// parent class.
|
|
|
|
if (gccgo_flag) {
|
|
Printv(f_go_wrappers, "//extern ", go_prefix, "_", upcall_wname, "\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "func ", upcall_gc_name, "(", go_type_name, NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
String *tm = goWrapperType(p, Getattr(p, "type"), false);
|
|
Printv(f_go_wrappers, ", ", tm, NULL);
|
|
Delete(tm);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ")", NULL);
|
|
|
|
if (SwigType_type(result) != T_VOID) {
|
|
String *tm = goWrapperType(n, result, true);
|
|
Printv(f_go_wrappers, " ", tm, NULL);
|
|
Delete(tm);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\n", NULL);
|
|
}
|
|
|
|
// Define the method on the director class in Go.
|
|
|
|
Printv(f_go_wrappers, "func (swig_p *", director_struct_name, ") ", go_with_over_name, "(", NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
if (i > 0) {
|
|
Printv(f_go_wrappers, ", ", NULL);
|
|
}
|
|
Printv(f_go_wrappers, Getattr(p, "lname"), " ", NULL);
|
|
String *tm = goType(p, Getattr(p, "type"));
|
|
Printv(f_go_wrappers, tm, NULL);
|
|
Delete(tm);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ")", NULL);
|
|
|
|
if (SwigType_type(result) != T_VOID) {
|
|
String *tm = goType(n, result);
|
|
Printv(f_go_wrappers, " ", tm, NULL);
|
|
Delete(tm);
|
|
}
|
|
|
|
Printv(f_go_wrappers, " {\n", NULL);
|
|
|
|
Printv(f_go_wrappers, "\tif swig_g, swig_ok := swig_p.v.(", interface_name, "); swig_ok {\n", NULL);
|
|
Printv(f_go_wrappers, "\t\t", NULL);
|
|
if (SwigType_type(result) != T_VOID) {
|
|
Printv(f_go_wrappers, "return ", NULL);
|
|
}
|
|
Printv(f_go_wrappers, "swig_g.", go_with_over_name, "(", NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
if (i > 0) {
|
|
Printv(f_go_wrappers, ", ", NULL);
|
|
}
|
|
Printv(f_go_wrappers, Getattr(p, "lname"), NULL);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ")\n", NULL);
|
|
if (SwigType_type(result) == T_VOID) {
|
|
Printv(f_go_wrappers, "\t\treturn\n", NULL);
|
|
}
|
|
Printv(f_go_wrappers, "\t}\n", NULL);
|
|
|
|
if (GetFlag(n, "abstract")) {
|
|
Printv(f_go_wrappers, "\tpanic(\"call to pure virtual method\")\n", NULL);
|
|
} else {
|
|
if (gccgo_flag) {
|
|
Printv(f_go_wrappers, "\tdefer SwigCgocallDone()\n", NULL);
|
|
Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\t", NULL);
|
|
if (SwigType_type(result) != T_VOID) {
|
|
Printv(f_go_wrappers, "return ", NULL);
|
|
}
|
|
Printv(f_go_wrappers, upcall_gc_name, "(swig_p.", go_type_name, NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
SwigType *pt = Getattr(p, "type");
|
|
Printv(f_go_wrappers, ", ", Getattr(p, "lname"), NULL);
|
|
if (goTypeIsInterface(p, pt)) {
|
|
Printv(f_go_wrappers, ".Swigcptr()", NULL);
|
|
}
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ")\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
// Define a method in the C++ director class that the C++ upcall
|
|
// function can call. This permits an upcall to a protected
|
|
// method.
|
|
|
|
if (!GetFlag(n, "abstract")) {
|
|
String *upcall_method_name = NewString("_swig_upcall_");
|
|
Append(upcall_method_name, name);
|
|
if (overname) {
|
|
Append(upcall_method_name, overname);
|
|
}
|
|
SwigType *rtype = Getattr(n, "classDirectorMethods:type");
|
|
String *upcall_decl = Swig_method_decl(rtype, Getattr(n, "decl"), upcall_method_name, parms, 0, 0);
|
|
Printv(f_c_directors_h, " ", upcall_decl, " {\n", NULL);
|
|
Delete(upcall_decl);
|
|
|
|
Printv(f_c_directors_h, " ", NULL);
|
|
if (SwigType_type(result) != T_VOID) {
|
|
Printv(f_c_directors_h, "return ", NULL);
|
|
}
|
|
|
|
String *super_call = Swig_method_call(super, parms);
|
|
Printv(f_c_directors_h, super_call, ";\n", NULL);
|
|
Delete(super_call);
|
|
|
|
Printv(f_c_directors_h, " }\n", NULL);
|
|
|
|
// Define the C++ function that the Go function calls.
|
|
|
|
SwigType *first_type = NULL;
|
|
Parm *first_parm = parms;
|
|
if (!is_static) {
|
|
first_type = NewString("SwigDirector_");
|
|
Append(first_type, class_name);
|
|
SwigType_add_pointer(first_type);
|
|
first_parm = NewParm(first_type, "p", n);
|
|
set_nextSibling(first_parm, parms);
|
|
}
|
|
|
|
Swig_save("classDirectorMethod", n, "wrap:name", "wrap:action", NULL);
|
|
|
|
Setattr(n, "wrap:name", upcall_wname);
|
|
|
|
String *action = NewString("");
|
|
if (SwigType_type(result) != T_VOID) {
|
|
Printv(action, Swig_cresult_name(), " = (", SwigType_lstr(result, 0), ")", NULL);
|
|
if (SwigType_isreference(result)) {
|
|
Printv(action, "&", NULL);
|
|
}
|
|
}
|
|
Printv(action, Swig_cparm_name(NULL, 0), "->", upcall_method_name, "(", NULL);
|
|
|
|
p = parms;
|
|
int i = 0;
|
|
while (p != NULL) {
|
|
if (SwigType_type(Getattr(p, "type")) != T_VOID) {
|
|
String *pname = Swig_cparm_name(NULL, i + 1);
|
|
if (i > 0) {
|
|
Printv(action, ", ", NULL);
|
|
}
|
|
|
|
// A parameter whose type is a reference is converted into a
|
|
// pointer type by gcCTypeForGoValue. We are calling a
|
|
// function which expects a reference so we need to convert
|
|
// back.
|
|
if (SwigType_isreference(Getattr(p, "type"))) {
|
|
Printv(action, "*", NULL);
|
|
}
|
|
|
|
Printv(action, pname, NULL);
|
|
Delete(pname);
|
|
i++;
|
|
}
|
|
p = nextSibling(p);
|
|
}
|
|
Printv(action, ");", NULL);
|
|
Setattr(n, "wrap:action", action);
|
|
|
|
if (!gccgo_flag) {
|
|
// Write the upcall wrapper function. This is compiled by gc
|
|
// and calls the C++ function.
|
|
int r = gcFunctionWrapper(n, upcall_name, upcall_name, overname, upcall_wname, first_parm, result, is_static, true);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
r = gccFunctionWrapper(n, NULL, upcall_wname, first_parm, result);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
} else {
|
|
int r = gccgoFunctionWrapper(n, NULL, upcall_wname, first_parm, result);
|
|
if (r != SWIG_OK) {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
Delete(first_type);
|
|
if (first_parm != parms) {
|
|
Delete(first_parm);
|
|
}
|
|
|
|
Swig_restore(n);
|
|
Delete(upcall_method_name);
|
|
|
|
// Define a function that uses the Go director type that other
|
|
// methods in the Go type can call to get parent methods.
|
|
|
|
Printv(f_go_wrappers, "func Director", cn, go_with_over_name, "(p ", cn, NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
Printv(f_go_wrappers, ", ", Getattr(p, "lname"), " ", NULL);
|
|
String *tm = goType(p, Getattr(p, "type"));
|
|
Printv(f_go_wrappers, tm, NULL);
|
|
Delete(tm);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ")", NULL);
|
|
|
|
if (SwigType_type(result) != T_VOID) {
|
|
String *tm = goType(n, result);
|
|
Printv(f_go_wrappers, " ", tm, NULL);
|
|
Delete(tm);
|
|
}
|
|
|
|
Printv(f_go_wrappers, " {\n", NULL);
|
|
|
|
if (gccgo_flag) {
|
|
Printv(f_go_wrappers, "\tdefer SwigCgocallDone()\n", NULL);
|
|
Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\t", NULL);
|
|
if (SwigType_type(result) != T_VOID) {
|
|
Printv(f_go_wrappers, "return ", NULL);
|
|
}
|
|
Printv(f_go_wrappers, upcall_gc_name, "(p.(*", director_struct_name, ").", go_type_name, NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
SwigType *pt = Getattr(p, "type");
|
|
Printv(f_go_wrappers, ", ", Getattr(p, "lname"), NULL);
|
|
if (goTypeIsInterface(p, pt)) {
|
|
Printv(f_go_wrappers, ".Swigcptr()", NULL);
|
|
}
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ")\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
}
|
|
|
|
// The Go function which invokes the method. This is called
|
|
// from by the C++ method on the director class.
|
|
|
|
Printv(f_go_wrappers, "func ", callback_name, "(p *", director_struct_name, NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
String *tm = goWrapperType(p, Getattr(p, "type"), false);
|
|
Printv(f_go_wrappers, ", ", Getattr(p, "lname"), " ", tm, NULL);
|
|
Delete(tm);
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ") ", NULL);
|
|
String *result_wrapper = NULL;
|
|
if (SwigType_type(result) != T_VOID) {
|
|
result_wrapper = goWrapperType(n, result, true);
|
|
Printv(f_go_wrappers, "(swig_result ", result_wrapper, ") ", NULL);
|
|
}
|
|
Printv(f_go_wrappers, "{\n", NULL);
|
|
|
|
if (gccgo_flag) {
|
|
Printv(f_go_wrappers, "\tSwigCgocallBack()\n", NULL);
|
|
Printv(f_go_wrappers, "\tdefer SwigCgocallBackDone()\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\t", NULL);
|
|
|
|
if (is_ignored) {
|
|
Printv(f_go_wrappers, "return\n", NULL);
|
|
} else {
|
|
bool result_is_interface = false;
|
|
if (SwigType_type(result) != T_VOID) {
|
|
Printv(f_go_wrappers, "return ", NULL);
|
|
result_is_interface = goTypeIsInterface(NULL, result);
|
|
if (result_is_interface) {
|
|
Printv(f_go_wrappers, result_wrapper, "(", NULL);
|
|
}
|
|
}
|
|
Printv(f_go_wrappers, "p.", go_with_over_name, "(", NULL);
|
|
|
|
p = parms;
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
if (i > 0) {
|
|
Printv(f_go_wrappers, ", ", NULL);
|
|
}
|
|
SwigType *pt = Getattr(p, "type");
|
|
|
|
// If the Go representation is an interface type class, then
|
|
// we are receiving a uintptr, and must convert to the
|
|
// interface.
|
|
bool is_interface = goTypeIsInterface(p, pt);
|
|
if (is_interface) {
|
|
// Passing is_result as true to goWrapperType gives us the
|
|
// name of the Go type we need to convert to an interface.
|
|
String *wt = goWrapperType(p, pt, true);
|
|
Printv(f_go_wrappers, wt, "(", NULL);
|
|
Delete(wt);
|
|
}
|
|
|
|
Printv(f_go_wrappers, Getattr(p, "lname"), NULL);
|
|
|
|
if (is_interface) {
|
|
Printv(f_go_wrappers, ")", NULL);
|
|
}
|
|
|
|
p = nextParm(p);
|
|
}
|
|
|
|
Printv(f_go_wrappers, ")", NULL);
|
|
|
|
if (result_is_interface) {
|
|
Printv(f_go_wrappers, ".Swigcptr())", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
Delete(result_wrapper);
|
|
|
|
Delete(upcall_wname);
|
|
Delete(upcall_gc_name);
|
|
|
|
// Build the C++ functions.
|
|
|
|
if (!gccgo_flag) {
|
|
Printv(f_c_directors, "extern \"C\" void ", callback_wname, "(void*, int);\n", NULL);
|
|
} else {
|
|
Printv(f_c_directors, "extern \"C\" ", NULL);
|
|
|
|
String *fnname = NewString("");
|
|
Printv(fnname, callback_wname, "(void*", NULL);
|
|
|
|
p = parms;
|
|
while (p) {
|
|
while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
|
|
p = Getattr(p, "tmap:directorin:next");
|
|
}
|
|
String *cg = gccgoCTypeForGoValue(p, Getattr(p, "type"),
|
|
Getattr(p, "lname"));
|
|
Printv(fnname, ", ", cg, NULL);
|
|
Delete(cg);
|
|
p = Getattr(p, "tmap:directorin:next");
|
|
}
|
|
|
|
Printv(fnname, ")", NULL);
|
|
|
|
if (SwigType_type(result) == T_VOID) {
|
|
Printv(f_c_directors, "void ", fnname, NULL);
|
|
} else {
|
|
String *tm = gccgoCTypeForGoValue(n, result, fnname);
|
|
Printv(f_c_directors, tm, NULL);
|
|
Delete(tm);
|
|
}
|
|
|
|
Delete(fnname);
|
|
|
|
Printv(f_c_directors, " __asm__(\"", go_prefix, ".", callback_name, "\");\n", NULL);
|
|
}
|
|
|
|
Delete(go_with_over_name);
|
|
}
|
|
|
|
if (!is_ignored || is_pure_virtual) {
|
|
// Declare the method for the director class.
|
|
|
|
SwigType *rtype = Getattr(n, "conversion_operator") ? 0 : Getattr(n, "classDirectorMethods:type");
|
|
String *decl = Swig_method_decl(rtype, Getattr(n, "decl"), Getattr(n, "name"), parms, 0, 0);
|
|
Printv(f_c_directors_h, " virtual ", decl, NULL);
|
|
Delete(decl);
|
|
|
|
String *qname = NewString("");
|
|
Printv(qname, "SwigDirector_", class_name, "::", Getattr(n, "name"), NULL);
|
|
decl = Swig_method_decl(rtype, Getattr(n, "decl"), qname, parms, 0, 0);
|
|
Printv(w->def, decl, NULL);
|
|
Delete(decl);
|
|
Delete(qname);
|
|
|
|
String *throws = buildThrow(n);
|
|
if (throws) {
|
|
Printv(f_c_directors_h, " ", throws, NULL);
|
|
Printv(w->def, " ", throws, NULL);
|
|
Delete(throws);
|
|
}
|
|
|
|
Printv(f_c_directors_h, ";\n", NULL);
|
|
|
|
Printv(w->def, " {\n", NULL);
|
|
|
|
if (SwigType_type(result) != T_VOID) {
|
|
Wrapper_add_local(w, "c_result", SwigType_lstr(result, "c_result"));
|
|
}
|
|
|
|
if (!is_ignored) {
|
|
if (!gccgo_flag) {
|
|
Printv(w->code, " struct {\n", NULL);
|
|
Printv(w->code, " void *go_val;\n", NULL);
|
|
|
|
p = parms;
|
|
while (p) {
|
|
while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
|
|
p = Getattr(p, "tmap:directorin:next");
|
|
}
|
|
String *ln = Getattr(p, "lname");
|
|
String *cg = gcCTypeForGoValue(p, Getattr(p, "type"), ln);
|
|
Printv(w->code, " ", cg, ";\n", NULL);
|
|
Delete(cg);
|
|
p = Getattr(p, "tmap:directorin:next");
|
|
}
|
|
if (SwigType_type(result) != T_VOID) {
|
|
Printv(w->code, " long : 0;\n", NULL);
|
|
String *rname = NewString(Swig_cresult_name());
|
|
String *cg = gcCTypeForGoValue(n, result, rname);
|
|
Printv(w->code, " ", cg, ";\n", NULL);
|
|
Delete(cg);
|
|
Delete(rname);
|
|
}
|
|
|
|
Printv(w->code, " } swig_a;\n", NULL);
|
|
Printv(w->code, " swig_a.go_val = go_val;\n", NULL);
|
|
|
|
p = parms;
|
|
while (p) {
|
|
while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
|
|
p = Getattr(p, "tmap:directorin:next");
|
|
}
|
|
String *tm = Getattr(p, "tmap:directorin");
|
|
if (!tm) {
|
|
Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file,
|
|
line_number, "Unable to use type %s as director method argument\n", SwigType_str(Getattr(p, "type"), 0));
|
|
} else {
|
|
String *ln = Getattr(p, "lname");
|
|
String *input = NewString("");
|
|
Printv(input, "swig_a.", ln, NULL);
|
|
Setattr(p, "emit:directorinput", input);
|
|
Replaceall(tm, "$input", input);
|
|
Replaceall(tm, "$owner", "0");
|
|
Delete(input);
|
|
Printv(w->code, "\t", tm, "\n", NULL);
|
|
}
|
|
p = Getattr(p, "tmap:directorin:next");
|
|
}
|
|
|
|
Printv(w->code, " crosscall2(", callback_wname, ", &swig_a, (int) sizeof swig_a);\n", NULL);
|
|
|
|
if (SwigType_type(result) != T_VOID) {
|
|
String *result_str = NewString("c_result");
|
|
String *tm = Swig_typemap_lookup("directorout", n, result_str, NULL);
|
|
if (!tm) {
|
|
Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
|
|
"Unable to use type %s as director method result\n", SwigType_str(result, 0));
|
|
} else {
|
|
static const String *swig_a_result = NewStringf("swig_a.%s", Swig_cresult_name());
|
|
Replaceall(tm, "$input", swig_a_result);
|
|
Replaceall(tm, "$result", "c_result");
|
|
Printv(w->code, " ", tm, "\n", NULL);
|
|
String *retstr = SwigType_rcaststr(result, "c_result");
|
|
Printv(w->code, " return ", retstr, ";\n", NULL);
|
|
Delete(retstr);
|
|
Delete(tm);
|
|
}
|
|
Delete(result_str);
|
|
}
|
|
|
|
// The C wrapper code which calls the Go function.
|
|
Printv(f_gc_wrappers, "#pragma dynexport ", callback_wname, " ", callback_wname, "\n", NULL);
|
|
Printv(f_gc_wrappers, "#pragma cgo_export_static ", callback_wname, " ", callback_wname, "\n", NULL);
|
|
Printv(f_gc_wrappers, "#pragma textflag 7\n", NULL);
|
|
Printv(f_gc_wrappers, "extern void \xc2\xb7", callback_name, "();\n", NULL);
|
|
Printv(f_gc_wrappers, "void\n", NULL);
|
|
Printv(f_gc_wrappers, callback_wname, "(void *a, int32 n)\n", NULL);
|
|
Printv(f_gc_wrappers, "{\n", NULL);
|
|
Printv(f_gc_wrappers, "\truntime\xc2\xb7" "cgocallback(\xc2\xb7", callback_name, ", a, n);\n", NULL);
|
|
Printv(f_gc_wrappers, "}\n\n", NULL);
|
|
} else {
|
|
if (SwigType_type(result) != T_VOID) {
|
|
String *r = NewString(Swig_cresult_name());
|
|
String *tm = gccgoCTypeForGoValue(n, result, r);
|
|
Wrapper_add_local(w, r, tm);
|
|
Delete(tm);
|
|
Delete(r);
|
|
}
|
|
|
|
String *args = NewString("");
|
|
|
|
p = parms;
|
|
while (p) {
|
|
while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
|
|
p = Getattr(p, "tmap:directorin:next");
|
|
}
|
|
|
|
String *pn = NewString("g");
|
|
Append(pn, Getattr(p, "lname"));
|
|
Setattr(p, "emit:input", pn);
|
|
|
|
String *tm = gccgoCTypeForGoValue(n, Getattr(p, "type"), pn);
|
|
Wrapper_add_local(w, pn, tm);
|
|
Delete(tm);
|
|
|
|
tm = Getattr(p, "tmap:directorin");
|
|
if (!tm) {
|
|
Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file,
|
|
line_number, "Unable to use type %s as director method argument\n", SwigType_str(Getattr(p, "type"), 0));
|
|
} else {
|
|
Replaceall(tm, "$input", pn);
|
|
Replaceall(tm, "$owner", 0);
|
|
Printv(w->code, " ", tm, "\n", NULL);
|
|
|
|
Printv(args, ", ", pn, NULL);
|
|
}
|
|
|
|
p = Getattr(p, "tmap:directorin:next");
|
|
}
|
|
|
|
Printv(w->code, " ", NULL);
|
|
if (SwigType_type(result) != T_VOID) {
|
|
Printv(w->code, Swig_cresult_name(), " = ", NULL);
|
|
}
|
|
Printv(w->code, callback_wname, "(go_val", args, ");\n", NULL);
|
|
|
|
if (SwigType_type(result) != T_VOID) {
|
|
String *result_str = NewString("c_result");
|
|
String *tm = Swig_typemap_lookup("directorout", n, result_str, NULL);
|
|
if (!tm) {
|
|
Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
|
|
"Unable to use type %s as director method result\n", SwigType_str(result, 0));
|
|
} else {
|
|
Replaceall(tm, "$input", Swig_cresult_name());
|
|
Replaceall(tm, "$result", "c_result");
|
|
Printv(w->code, " ", tm, "\n", NULL);
|
|
String *retstr = SwigType_rcaststr(result, "c_result");
|
|
Printv(w->code, " return ", retstr, ";\n", NULL);
|
|
Delete(retstr);
|
|
Delete(tm);
|
|
}
|
|
Delete(result_str);
|
|
}
|
|
}
|
|
|
|
/* Marshal outputs */
|
|
for (p = parms; p;) {
|
|
String *tm;
|
|
if ((tm = Getattr(p, "tmap:directorargout"))) {
|
|
Replaceall(tm, "$result", "jresult");
|
|
Replaceall(tm, "$input", Getattr(p, "emit:directorinput"));
|
|
Printv(w->code, tm, "\n", NIL);
|
|
p = Getattr(p, "tmap:directorargout:next");
|
|
} else {
|
|
p = nextSibling(p);
|
|
}
|
|
}
|
|
} else {
|
|
assert(is_pure_virtual);
|
|
Printv(w->code, " _swig_gopanic(\"call to pure virtual function ", Getattr(parent, "sym:name"), name, "\");\n", NULL);
|
|
if (SwigType_type(result) != T_VOID) {
|
|
String *retstr = SwigType_rcaststr(result, "c_result");
|
|
Printv(w->code, " return ", retstr, ";\n", NULL);
|
|
Delete(retstr);
|
|
}
|
|
}
|
|
|
|
Printv(w->code, "}", NULL);
|
|
|
|
Replaceall(w->code, "$symname", symname);
|
|
Wrapper_print(w, f_c_directors);
|
|
}
|
|
|
|
Delete(cn);
|
|
Delete(go_type_name);
|
|
Delete(director_struct_name);
|
|
Delete(interface_name);
|
|
Delete(upcall_name);
|
|
Delete(callback_wname);
|
|
Delete(go_name);
|
|
DelWrapper(w);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* classDirectorEnd
|
|
*
|
|
* Complete support for a director class.
|
|
* ------------------------------------------------------------ */
|
|
|
|
int classDirectorEnd(Node *n) {
|
|
(void) n;
|
|
|
|
Printv(f_c_directors_h, " private:\n", NULL);
|
|
Printv(f_c_directors_h, " void *go_val;\n", NULL);
|
|
Printv(f_c_directors_h, "};\n\n", NULL);
|
|
|
|
class_name = NULL;
|
|
class_node = NULL;
|
|
|
|
Delete(class_receiver);
|
|
class_receiver = NULL;
|
|
|
|
Delete(class_methods);
|
|
class_methods = NULL;
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------
|
|
* classDirectorDisown
|
|
*
|
|
* I think Go does not require a disown method.
|
|
* ------------------------------------------------------------ */
|
|
|
|
int classDirectorDisown(Node *n) {
|
|
(void) n;
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
* buildThrow()
|
|
*
|
|
* Build and return a throw clause if needed.
|
|
*--------------------------------------------------------------------*/
|
|
|
|
String *buildThrow(Node *n) {
|
|
ParmList *throw_parm_list = Getattr(n, "throws");
|
|
if (!throw_parm_list && !Getattr(n, "throw"))
|
|
return NULL;
|
|
String *ret = NewString("throw(");
|
|
if (throw_parm_list) {
|
|
Swig_typemap_attach_parms("throws", throw_parm_list, NULL);
|
|
}
|
|
bool first = true;
|
|
for (Parm *p = throw_parm_list; p; p = nextSibling(p)) {
|
|
if (Getattr(p, "tmap:throws")) {
|
|
if (first) {
|
|
first = false;
|
|
} else {
|
|
Printv(ret, ", ", NULL);
|
|
}
|
|
String *s = SwigType_str(Getattr(p, "type"), 0);
|
|
Printv(ret, s, NULL);
|
|
Delete(s);
|
|
}
|
|
}
|
|
Printv(ret, ")", NULL);
|
|
return ret;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
* extraDirectorProtectedCPPMethodsRequired()
|
|
*
|
|
* We don't need to check upcall when calling methods.
|
|
*--------------------------------------------------------------------*/
|
|
|
|
bool extraDirectorProtectedCPPMethodsRequired() const {
|
|
return false;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
* makeDispatchFunction
|
|
*
|
|
* Make a dispatch function for an overloaded C++ function. The
|
|
* receiver parameter is the receiver for a method, unless is_upcall
|
|
* is true. If is_upcall is true, then the receiver parameter is
|
|
* the type of the first argument to the function.
|
|
*--------------------------------------------------------------------*/
|
|
|
|
int makeDispatchFunction(Node *n, String *go_name, String *receiver, bool is_static, SwigType *director_struct, bool is_upcall) {
|
|
bool is_director = director_struct ? true : false;
|
|
|
|
String *nodetype = Getattr(n, "nodeType");
|
|
bool is_constructor = Cmp(nodetype, "constructor") == 0;
|
|
bool is_destructor = Cmp(nodetype, "destructor") == 0;
|
|
|
|
bool can_use_receiver = (!is_constructor && !is_destructor && !is_upcall);
|
|
|
|
bool use_receiver = (!is_static && can_use_receiver);
|
|
|
|
bool add_to_interface = (interfaces && !is_constructor && !is_destructor && !is_static && !is_upcall);
|
|
|
|
List *dispatch = Swig_overload_rank(n, false);
|
|
int nfunc = Len(dispatch);
|
|
|
|
SwigType *all_result;
|
|
bool mismatch;
|
|
if (is_constructor) {
|
|
assert(!is_upcall);
|
|
if (!is_director) {
|
|
all_result = Copy(Getattr(class_node, "classtypeobj"));
|
|
} else {
|
|
all_result = Copy(director_struct);
|
|
}
|
|
mismatch = false;
|
|
} else {
|
|
all_result = NULL;
|
|
mismatch = false;
|
|
bool any_void = false;
|
|
for (int i = 0; i < nfunc; ++i) {
|
|
Node *nn = Getitem(dispatch, i);
|
|
Node *ni = Getattr(nn, "directorNode") ? Getattr(nn, "directorNode") : nn;
|
|
SwigType *result = Getattr(ni, "go:type");
|
|
assert(result);
|
|
|
|
if (SwigType_type(result) == T_VOID) {
|
|
if (all_result) {
|
|
mismatch = true;
|
|
}
|
|
any_void = true;
|
|
} else {
|
|
if (any_void) {
|
|
mismatch = true;
|
|
} else if (!all_result) {
|
|
all_result = Copy(result);
|
|
} else if (Cmp(result, all_result) != 0) {
|
|
mismatch = true;
|
|
}
|
|
}
|
|
}
|
|
if (mismatch) {
|
|
Delete(all_result);
|
|
all_result = NULL;
|
|
} else if (all_result) {
|
|
;
|
|
} else {
|
|
all_result = NewString("void");
|
|
}
|
|
}
|
|
|
|
Printv(f_go_wrappers, "func ", NULL);
|
|
|
|
if (receiver && use_receiver) {
|
|
Printv(f_go_wrappers, "(p ", receiver, ") ", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, go_name, "(", NULL);
|
|
if (is_director && is_constructor) {
|
|
Printv(f_go_wrappers, "abi interface{}, ", NULL);
|
|
assert(!add_to_interface);
|
|
}
|
|
if (is_upcall) {
|
|
Printv(f_go_wrappers, "p *", receiver, ", ", NULL);
|
|
assert(!add_to_interface);
|
|
}
|
|
Printv(f_go_wrappers, "a ...interface{})", NULL);
|
|
|
|
if (add_to_interface) {
|
|
Printv(interfaces, "\t", go_name, "(a ...interface{})", NULL);
|
|
}
|
|
|
|
if (mismatch) {
|
|
Printv(f_go_wrappers, " interface{}", NULL);
|
|
if (add_to_interface) {
|
|
Printv(interfaces, " interface{}", NULL);
|
|
}
|
|
} else if (all_result && SwigType_type(all_result) != T_VOID) {
|
|
if (is_director && is_constructor) {
|
|
Printv(f_go_wrappers, " ", receiver, NULL);
|
|
if (add_to_interface) {
|
|
Printv(interfaces, " ", receiver, NULL);
|
|
}
|
|
} else {
|
|
String *tm = goType(n, all_result);
|
|
Printv(f_go_wrappers, " ", tm, NULL);
|
|
if (add_to_interface) {
|
|
Printv(interfaces, " ", tm, NULL);
|
|
}
|
|
Delete(tm);
|
|
}
|
|
}
|
|
Printv(f_go_wrappers, " {\n", NULL);
|
|
if (add_to_interface) {
|
|
Printv(interfaces, "\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\targc := len(a)\n", NULL);
|
|
|
|
for (int i = 0; i < nfunc; ++i) {
|
|
int fn = 0;
|
|
Node *nn = Getitem(dispatch, i);
|
|
Node *ni = Getattr(nn, "directorNode") ? Getattr(nn, "directorNode") : nn;
|
|
Parm *pi = Getattr(ni, "wrap:parms");
|
|
|
|
// If we are using a receiver, we want to ignore a leading self
|
|
// parameter. Because of the way this is called, there may or
|
|
// may not be a self parameter at this point.
|
|
if (use_receiver && pi && Getattr(pi, "self")) {
|
|
pi = getParm(pi);
|
|
if (pi) {
|
|
pi = nextParm(pi);
|
|
}
|
|
}
|
|
|
|
int num_required = emit_num_required(pi);
|
|
int num_arguments = emit_num_arguments(pi);
|
|
bool varargs = emit_isvarargs(pi) ? true : false;
|
|
|
|
if (varargs) {
|
|
Printf(f_go_wrappers, "\tif argc >= %d {\n", num_required);
|
|
} else {
|
|
if (num_required == num_arguments) {
|
|
Printf(f_go_wrappers, "\tif argc == %d {\n", num_required);
|
|
} else {
|
|
Printf(f_go_wrappers, "\tif argc >= %d && argc <= %d {\n", num_required, num_arguments);
|
|
}
|
|
}
|
|
|
|
// Build list of collisions with the same number of arguments.
|
|
List *coll = NewList();
|
|
for (int k = i + 1; k < nfunc; ++k) {
|
|
Node *nnk = Getitem(dispatch, k);
|
|
Node *nk = Getattr(nnk, "directorNode") ? Getattr(nnk, "directorNode") : nnk;
|
|
Parm *pk = Getattr(nk, "wrap:parms");
|
|
if (use_receiver && pk && Getattr(pk, "self")) {
|
|
pk = getParm(pk);
|
|
if (pk) {
|
|
pk = nextParm(pk);
|
|
}
|
|
}
|
|
int nrk = emit_num_required(pk);
|
|
int nak = emit_num_arguments(pk);
|
|
if ((nrk >= num_required && nrk <= num_arguments)
|
|
|| (nak >= num_required && nak <= num_arguments)
|
|
|| (nrk <= num_required && nak >= num_arguments)
|
|
|| (varargs && nrk >= num_required)) {
|
|
Append(coll, nk);
|
|
}
|
|
}
|
|
|
|
int num_braces = 0;
|
|
if (Len(coll) > 0 && num_arguments > 0) {
|
|
int j = 0;
|
|
Parm *pj = pi;
|
|
while (pj) {
|
|
pj = getParm(pj);
|
|
if (!pj) {
|
|
break;
|
|
}
|
|
|
|
// If all the wrappers have the same type in this position,
|
|
// we can omit the check.
|
|
SwigType *tm = goWrapperType(pj, Getattr(pj, "type"), true);
|
|
bool emitcheck = false;
|
|
for (int k = 0; k < Len(coll) && !emitcheck; ++k) {
|
|
Node *nk = Getitem(coll, k);
|
|
Parm *pk = Getattr(nk, "wrap:parms");
|
|
if (use_receiver && pk && Getattr(pk, "self")) {
|
|
pk = getParm(pk);
|
|
if (pk) {
|
|
pk = nextParm(pk);
|
|
}
|
|
}
|
|
int nak = emit_num_arguments(pk);
|
|
if (nak <= j)
|
|
continue;
|
|
int l = 0;
|
|
Parm *pl = pk;
|
|
while (pl && l <= j) {
|
|
pl = getParm(pl);
|
|
if (!pl) {
|
|
break;
|
|
}
|
|
if (l == j) {
|
|
SwigType *tml = goWrapperType(pl, Getattr(pl, "type"), true);
|
|
if (Cmp(tm, tml) != 0) {
|
|
emitcheck = true;
|
|
}
|
|
Delete(tml);
|
|
}
|
|
pl = nextParm(pl);
|
|
++l;
|
|
}
|
|
}
|
|
|
|
if (emitcheck) {
|
|
if (j >= num_required) {
|
|
Printf(f_go_wrappers, "\t\tif argc > %d {\n", j);
|
|
++num_braces;
|
|
}
|
|
|
|
fn = i + 1;
|
|
Printf(f_go_wrappers, "\t\tif _, ok := a[%d].(%s); !ok {\n", j, tm);
|
|
Printf(f_go_wrappers, "\t\t\tgoto check_%d\n", fn);
|
|
Printv(f_go_wrappers, "\t\t}\n", NULL);
|
|
}
|
|
|
|
Delete(tm);
|
|
|
|
pj = nextParm(pj);
|
|
|
|
++j;
|
|
}
|
|
}
|
|
|
|
for (; num_braces > 0; --num_braces) {
|
|
Printv(f_go_wrappers, "\t\t}\n", NULL);
|
|
}
|
|
|
|
// We may need to generate multiple calls if there are variable
|
|
// argument lists involved. Build the start of the call.
|
|
|
|
String *start = NewString("");
|
|
|
|
SwigType *result = Getattr(ni, "go:type");
|
|
|
|
if (is_constructor) {
|
|
result = all_result;
|
|
} else if (is_destructor) {
|
|
result = NULL;
|
|
}
|
|
|
|
if (result && SwigType_type(result) != T_VOID && (!all_result || SwigType_type(all_result) != T_VOID)) {
|
|
Printv(start, "return ", NULL);
|
|
}
|
|
|
|
bool advance_parm = false;
|
|
|
|
if (receiver && use_receiver) {
|
|
Printv(start, "p.", go_name, NULL);
|
|
} else if (can_use_receiver && !isStatic(ni) && pi && Getattr(pi, "self")) {
|
|
// This is an overload of a static function and a non-static
|
|
// function.
|
|
assert(num_required > 0);
|
|
SwigType *tm = goWrapperType(pi, Getattr(pi, "type"), true);
|
|
String *nm = buildGoName(Getattr(ni, "sym:name"), false, isFriend(ni));
|
|
Printv(start, "a[0].(", tm, ").", nm, NULL);
|
|
Delete(nm);
|
|
Delete(tm);
|
|
advance_parm = true;
|
|
} else {
|
|
Printv(start, go_name, NULL);
|
|
}
|
|
|
|
Printv(start, Getattr(ni, "sym:overname"), "(", NULL);
|
|
|
|
bool need_comma = false;
|
|
|
|
if (is_director && is_constructor) {
|
|
Printv(start, "abi", NULL);
|
|
need_comma = true;
|
|
}
|
|
if (is_upcall) {
|
|
Printv(start, "p", NULL);
|
|
need_comma = true;
|
|
}
|
|
Parm *p = pi;
|
|
int pn = 0;
|
|
if (advance_parm) {
|
|
p = getParm(p);
|
|
if (p) {
|
|
p = nextParm(p);
|
|
}
|
|
++pn;
|
|
}
|
|
while (pn < num_required) {
|
|
p = getParm(p);
|
|
|
|
if (need_comma) {
|
|
Printv(start, ", ", NULL);
|
|
}
|
|
|
|
SwigType *tm = goType(p, Getattr(p, "type"));
|
|
Printf(start, "a[%d].(%s)", pn, tm);
|
|
Delete(tm);
|
|
|
|
need_comma = true;
|
|
++pn;
|
|
p = nextParm(p);
|
|
}
|
|
|
|
String *end = NULL;
|
|
if (!result || SwigType_type(result) == T_VOID || (all_result && SwigType_type(all_result) == T_VOID)) {
|
|
end = NewString("");
|
|
Printv(end, "return", NULL);
|
|
if (!all_result || SwigType_type(all_result) != T_VOID) {
|
|
Printv(end, " 0", NULL);
|
|
}
|
|
}
|
|
|
|
if (num_required == num_arguments) {
|
|
Printv(f_go_wrappers, "\t\t", start, ")\n", NULL);
|
|
if (end) {
|
|
Printv(f_go_wrappers, "\t\t", end, "\n", NULL);
|
|
}
|
|
} else {
|
|
Printv(f_go_wrappers, "\t\tswitch argc {\n", NULL);
|
|
for (int j = num_required; j <= num_arguments; ++j) {
|
|
Printf(f_go_wrappers, "\t\tcase %d:\n", j);
|
|
Printv(f_go_wrappers, "\t\t\t", start, NULL);
|
|
bool nc = need_comma;
|
|
for (int k = num_required; k < j; ++k) {
|
|
if (nc) {
|
|
Printv(f_go_wrappers, ", ", NULL);
|
|
}
|
|
Printf(f_go_wrappers, "a[%d]", k);
|
|
nc = true;
|
|
}
|
|
Printv(f_go_wrappers, ")\n", NULL);
|
|
if (end) {
|
|
Printv(f_go_wrappers, "\t\t\t", end, "\n", NULL);
|
|
}
|
|
}
|
|
Printv(f_go_wrappers, "\t\t}\n", NULL);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\t}\n", NULL);
|
|
|
|
if (fn != 0) {
|
|
Printf(f_go_wrappers, "check_%d:\n", fn);
|
|
}
|
|
|
|
Delete(coll);
|
|
}
|
|
|
|
Printv(f_go_wrappers, "\tpanic(\"No match for overloaded function call\")\n", NULL);
|
|
Printv(f_go_wrappers, "}\n\n", NULL);
|
|
|
|
Delete(all_result);
|
|
Delete(dispatch);
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* checkFunctionVisibility()
|
|
*
|
|
* Return true if we should write out a function based on its
|
|
* visibility, false otherwise.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
bool checkFunctionVisibility(Node *n, Node *parent) {
|
|
// Write out a public function.
|
|
if (is_public(n))
|
|
return true;
|
|
// Don't write out a private function.
|
|
if (is_private(n))
|
|
return false;
|
|
// Write a protected function for a director class in
|
|
// dirprot_mode.
|
|
if (parent == NULL) {
|
|
return false;
|
|
}
|
|
if (dirprot_mode() && Swig_directorclass(parent))
|
|
return true;
|
|
// Otherwise don't write out a protected function.
|
|
return false;
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* exportedName()
|
|
*
|
|
* Given a C/C++ name, return a name in Go which will be exported.
|
|
* If the first character is an upper case letter, this returns a
|
|
* copy of its argment. If the first character is a lower case
|
|
* letter, this forces it to upper case. Otherwise, this prepends
|
|
* 'X'.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *exportedName(String *name) {
|
|
String *copy = Copy(name);
|
|
char c = *Char(copy);
|
|
if (islower(c)) {
|
|
char l[2];
|
|
char u[2];
|
|
l[0] = c;
|
|
l[1] = '\0';
|
|
u[0] = toupper(c);
|
|
u[1] = '\0';
|
|
Replace(copy, l, u, DOH_REPLACE_FIRST);
|
|
} else if (!isalpha(c)) {
|
|
char l[2];
|
|
char u[3];
|
|
l[0] = c;
|
|
l[1] = '\0';
|
|
u[0] = 'X';
|
|
u[1] = c;
|
|
u[2] = '\0';
|
|
Replace(copy, l, u, DOH_REPLACE_FIRST);
|
|
}
|
|
String *ret = Swig_name_mangle(copy);
|
|
Delete(copy);
|
|
return ret;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* removeClassname()
|
|
*
|
|
* If the name starts with the current class name, followed by an
|
|
* underscore, remove it. If there is no current class name, this
|
|
* simply returns a copy of the name. This undoes Swig's way of
|
|
* recording the class name in a member name.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *removeClassname(String *name) {
|
|
String *copy = Copy(name);
|
|
if (class_name) {
|
|
char *p = Char(name);
|
|
if (Strncmp(name, class_name, Len(class_name)) == 0 && p[Len(class_name)] == '_') {
|
|
Replace(copy, class_name, "", DOH_REPLACE_FIRST);
|
|
Replace(copy, "_", "", DOH_REPLACE_FIRST);
|
|
}
|
|
}
|
|
return copy;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* buildGoName()
|
|
*
|
|
* Build the name to use for an ordinary function, variable, or
|
|
* whatever in Go. The name argument is something like the sym:name
|
|
* attribute of the node. If is_static is false, this could be a
|
|
* method, and the returned name will be the name of the
|
|
* method--i.e., it will not include the class name.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *buildGoName(String *name, bool is_static, bool is_friend) {
|
|
String *nw = NewString("");
|
|
if (is_static && !is_friend && class_name) {
|
|
String *c1 = exportedName(class_name);
|
|
Append(nw, c1);
|
|
Delete(c1);
|
|
}
|
|
String *c2 = removeClassname(name);
|
|
String *c3 = exportedName(c2);
|
|
Append(nw, c3);
|
|
Delete(c2);
|
|
Delete(c3);
|
|
String *ret = Swig_name_mangle(nw);
|
|
Delete(nw);
|
|
return ret;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* buildGoWrapperName()
|
|
*
|
|
* Build the name to use for a Go wrapper function. This is a
|
|
* function called by the real Go function in order to convert C++
|
|
* classes from interfaces to pointers, and other such conversions
|
|
* between the Go type and the C++ type.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *buildGoWrapperName(String *name, String *overname) {
|
|
String *s1 = NewString("_swig_wrap_");
|
|
Append(s1, name);
|
|
String *s2 = Swig_name_mangle(s1);
|
|
Delete(s1);
|
|
if (overname) {
|
|
Append(s2, overname);
|
|
}
|
|
return s2;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* checkNameConflict()
|
|
*
|
|
* Check for a name conflict on the name we are going to use in Go.
|
|
* These conflicts are likely because of the enforced
|
|
* capitalization. When we find one, issue a warning and return
|
|
* false. If the name is OK, return true.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
bool checkNameConflict(String* name, Node* n, const_String_or_char_ptr scope) {
|
|
Node *lk = symbolLookup(name, scope);
|
|
if (lk) {
|
|
String *n1 = Getattr(n, "sym:name");
|
|
if (!n1) {
|
|
n1 = Getattr(n, "name");
|
|
}
|
|
String *n2 = Getattr(lk, "sym:name");
|
|
if (!n2) {
|
|
n2 = Getattr(lk, "name");
|
|
}
|
|
Swig_warning(WARN_GO_NAME_CONFLICT, input_file, line_number,
|
|
"Ignoring '%s' due to Go name ('%s') conflict with '%s'\n",
|
|
n1, name, n2);
|
|
return false;
|
|
}
|
|
bool r = addSymbol(name, n, scope) ? true : false;
|
|
assert(r);
|
|
return true;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* checkIgnoredParameters()
|
|
*
|
|
* If any of the parameters of this function, or the return type,
|
|
* are ignored due to a name conflict, give a warning and return
|
|
* false.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
bool checkIgnoredParameters(Node *n, String *go_name) {
|
|
ParmList *parms = Getattr(n, "parms");
|
|
if (parms) {
|
|
Wrapper *dummy = NewWrapper();
|
|
emit_attach_parmmaps(parms, dummy);
|
|
int parm_count = emit_num_arguments(parms);
|
|
Parm *p = parms;
|
|
|
|
for (int i = 0; i < parm_count; ++i) {
|
|
p = getParm(p);
|
|
if (!checkIgnoredType(n, go_name, Getattr(p, "type"))) {
|
|
DelWrapper(dummy);
|
|
return false;
|
|
}
|
|
p = nextParm(p);
|
|
}
|
|
|
|
DelWrapper(dummy);
|
|
}
|
|
|
|
if (!checkIgnoredType(n, go_name, Getattr(n, "type"))) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* checkIgnoredType()
|
|
*
|
|
* If this type is being ignored due to a name conflict, give a
|
|
* warning and return false.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
bool checkIgnoredType(Node *n, String *go_name, SwigType *type) {
|
|
if (hasGoTypemap(n, type)) {
|
|
return true;
|
|
}
|
|
|
|
SwigType *t = SwigType_typedef_resolve_all(type);
|
|
|
|
bool ret = true;
|
|
bool is_conflict = false;
|
|
Node *e = Language::enumLookup(t);
|
|
if (e) {
|
|
if (GetFlag(e, "go:conflict")) {
|
|
is_conflict = true;
|
|
}
|
|
} else if (SwigType_issimple(t)) {
|
|
Node *cn = classLookup(t);
|
|
if (cn) {
|
|
if (GetFlag(cn, "go:conflict")) {
|
|
is_conflict = true;
|
|
}
|
|
}
|
|
} else if (SwigType_ispointer(t) || SwigType_isarray(t) || SwigType_isqualifier(t) || SwigType_isreference(t)) {
|
|
SwigType *r = Copy(t);
|
|
if (SwigType_ispointer(r)) {
|
|
SwigType_del_pointer(r);
|
|
} else if (SwigType_isarray(r)) {
|
|
SwigType_del_array(r);
|
|
} else if (SwigType_isqualifier(r)) {
|
|
SwigType_del_qualifier(r);
|
|
} else {
|
|
SwigType_del_reference(r);
|
|
}
|
|
|
|
if (!checkIgnoredType(n, go_name, r)) {
|
|
ret = false;
|
|
}
|
|
|
|
Delete(r);
|
|
}
|
|
|
|
if (is_conflict) {
|
|
String *s = SwigType_str(t, NULL);
|
|
Swig_warning(WARN_GO_NAME_CONFLICT, input_file, line_number,
|
|
"Ignoring '%s' (Go name '%s') due to Go name conflict for parameter or result type '%s'\n",
|
|
Getattr(n, "name"), go_name, s);
|
|
Delete(s);
|
|
ret = false;
|
|
}
|
|
|
|
Delete(t);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* goType()
|
|
*
|
|
* Given a SWIG type, return a string for the type in Go.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *goType(Node *n, SwigType *type) {
|
|
return goTypeWithInfo(n, type, NULL);
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* goTypeWithInfo()
|
|
*
|
|
* Like goType, but return some more information.
|
|
*
|
|
* If the p_is_interface parameter is not NULL, this sets
|
|
* *p_is_interface to indicate whether this type is going to be
|
|
* represented by a Go interface type. These are cases where the Go
|
|
* code needs to make some adjustments when passing values back and
|
|
* forth with C/C++.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *goTypeWithInfo(Node *n, SwigType *type, bool *p_is_interface) {
|
|
if (p_is_interface) {
|
|
*p_is_interface = false;
|
|
}
|
|
|
|
String *ret;
|
|
if (n && Cmp(type, Getattr(n, "type")) == 0) {
|
|
ret = NULL;
|
|
if (Strcmp(Getattr(n, "nodeType"), "parm") == 0) {
|
|
ret = Getattr(n, "tmap:gotype");
|
|
}
|
|
if (!ret) {
|
|
ret = Swig_typemap_lookup("gotype", n, "", NULL);
|
|
}
|
|
} else {
|
|
Parm *p = NewParm(type, "goType", n);
|
|
ret = Swig_typemap_lookup("gotype", p, "", NULL);
|
|
Delete(p);
|
|
}
|
|
|
|
if (ret && Strstr(ret, "$gotypename") != 0) {
|
|
ret = NULL;
|
|
}
|
|
|
|
if (ret) {
|
|
return Copy(ret);
|
|
}
|
|
|
|
SwigType *t = SwigType_typedef_resolve_all(type);
|
|
|
|
if (SwigType_isenum(t)) {
|
|
Node *e = Language::enumLookup(t);
|
|
if (e) {
|
|
ret = goEnumName(e);
|
|
} else if (Strcmp(t, "enum ") == 0) {
|
|
ret = NewString("int");
|
|
} else {
|
|
// An unknown enum - one that has not been parsed (neither a C enum forward reference nor a definition) or an ignored enum
|
|
String *tt = Copy(t);
|
|
Replace(tt, "enum ", "", DOH_REPLACE_ANY);
|
|
ret = exportedName(tt);
|
|
Setattr(undefined_enum_types, t, ret);
|
|
Delete(tt);
|
|
}
|
|
} else if (SwigType_isfunctionpointer(type) || SwigType_isfunction(type)) {
|
|
ret = NewString("_swig_fnptr");
|
|
} else if (SwigType_ismemberpointer(type)) {
|
|
ret = NewString("_swig_memberptr");
|
|
} else if (SwigType_issimple(t)) {
|
|
Node *cn = classLookup(t);
|
|
if (cn) {
|
|
ret = Getattr(cn, "sym:name");
|
|
if (!ret) {
|
|
ret = Getattr(cn, "name");
|
|
}
|
|
ret = exportedName(ret);
|
|
|
|
Node *cnmod = Getattr(cn, "module");
|
|
if (!cnmod || Strcmp(Getattr(cnmod, "name"), module) == 0) {
|
|
Setattr(undefined_types, t, t);
|
|
} else {
|
|
String *nw = NewString("");
|
|
Printv(nw, Getattr(cnmod, "name"), ".", ret, NULL);
|
|
Delete(ret);
|
|
ret = nw;
|
|
}
|
|
} else {
|
|
// SWIG does not know about this type.
|
|
ret = exportedName(t);
|
|
Setattr(undefined_types, t, t);
|
|
}
|
|
if (p_is_interface) {
|
|
*p_is_interface = true;
|
|
}
|
|
} else if (SwigType_ispointer(t) || SwigType_isarray(t)) {
|
|
SwigType *r = Copy(t);
|
|
if (SwigType_ispointer(r)) {
|
|
SwigType_del_pointer(r);
|
|
} else {
|
|
SwigType_del_array(r);
|
|
}
|
|
|
|
if (SwigType_type(r) == T_VOID) {
|
|
ret = NewString("uintptr");
|
|
} else {
|
|
bool is_interface;
|
|
String *base = goTypeWithInfo(n, r, &is_interface);
|
|
|
|
// At the Go level, an unknown or class type is handled as an
|
|
// interface wrapping a pointer. This means that if a
|
|
// function returns the C type X, we will be wrapping the C
|
|
// type X*. In Go we will call that type X. That means that
|
|
// if a C function expects X*, we can pass the Go type X. And
|
|
// that means that when we see the C type X*, we should use
|
|
// the Go type X.
|
|
|
|
// The is_interface variable tells us this. However, it will
|
|
// be true both for the case of X and for the case of X*. If
|
|
// r is a pointer here, then we are looking at X**. There is
|
|
// really no good way for us to handle that.
|
|
bool is_pointer_to_pointer = false;
|
|
if (is_interface) {
|
|
SwigType *c = Copy(r);
|
|
if (SwigType_isqualifier(c)) {
|
|
SwigType_del_qualifier(c);
|
|
if (SwigType_ispointer(c) || SwigType_isarray(c)) {
|
|
is_pointer_to_pointer = true;
|
|
}
|
|
}
|
|
Delete(c);
|
|
}
|
|
|
|
if (is_interface) {
|
|
if (!is_pointer_to_pointer) {
|
|
ret = base;
|
|
if (p_is_interface) {
|
|
*p_is_interface = true;
|
|
}
|
|
} else {
|
|
ret = NewString("uintptr");
|
|
}
|
|
} else {
|
|
ret = NewString("*");
|
|
Append(ret, base);
|
|
Delete(base);
|
|
}
|
|
}
|
|
|
|
Delete(r);
|
|
} else if (SwigType_isreference(t)) {
|
|
SwigType *r = Copy(t);
|
|
SwigType_del_reference(r);
|
|
|
|
// If this is a const reference, and we are looking at a pointer
|
|
// to it, then we just use the pointer we already have.
|
|
bool add_pointer = true;
|
|
if (SwigType_isqualifier(r)) {
|
|
String *q = SwigType_parm(r);
|
|
if (Strcmp(q, "const") == 0) {
|
|
SwigType *c = Copy(r);
|
|
SwigType_del_qualifier(c);
|
|
if (SwigType_ispointer(c)) {
|
|
add_pointer = false;
|
|
}
|
|
Delete(c);
|
|
}
|
|
}
|
|
if (add_pointer) {
|
|
SwigType_add_pointer(r);
|
|
}
|
|
ret = goTypeWithInfo(n, r, p_is_interface);
|
|
Delete(r);
|
|
} else if (SwigType_isqualifier(t)) {
|
|
SwigType *r = Copy(t);
|
|
SwigType_del_qualifier(r);
|
|
ret = goTypeWithInfo(n, r, p_is_interface);
|
|
Delete(r);
|
|
} else if (SwigType_isvarargs(t)) {
|
|
ret = NewString("[]interface{}");
|
|
}
|
|
|
|
Delete(t);
|
|
|
|
if (!ret) {
|
|
Swig_warning(WARN_LANG_NATIVE_UNIMPL, input_file, line_number, "No Go typemap defined for %s\n", SwigType_str(type, 0));
|
|
ret = NewString("uintptr");
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* goWrapperType()
|
|
*
|
|
* Given a type, return a string for the type to use for the wrapped
|
|
* Go function. This function exists because for a C++ class we
|
|
* need to convert interface and reference types.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *goWrapperType(Node *n, SwigType *type, bool is_result) {
|
|
bool is_interface;
|
|
String *ret = goTypeWithInfo(n, type, &is_interface);
|
|
|
|
// If this is an interface, we want to pass the real type.
|
|
if (is_interface) {
|
|
Delete(ret);
|
|
if (!is_result) {
|
|
ret = NewString("uintptr");
|
|
} else {
|
|
SwigType *ty = SwigType_typedef_resolve_all(type);
|
|
while (true) {
|
|
if (SwigType_ispointer(ty)) {
|
|
SwigType_del_pointer(ty);
|
|
} else if (SwigType_isarray(ty)) {
|
|
SwigType_del_array(ty);
|
|
} else if (SwigType_isreference(ty)) {
|
|
SwigType_del_reference(ty);
|
|
} else if (SwigType_isqualifier(ty)) {
|
|
SwigType_del_qualifier(ty);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
assert(SwigType_issimple(ty));
|
|
String *p = goCPointerType(ty, true);
|
|
Delete(ty);
|
|
ret = p;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* goCPointerType()
|
|
*
|
|
* Return the name of the Go type to use for the C pointer value.
|
|
* The regular C type is the name of an interface type which wraps a
|
|
* pointer whose name is returned by this function.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *goCPointerType(SwigType *type, bool add_to_hash) {
|
|
SwigType *ty = SwigType_typedef_resolve_all(type);
|
|
Node *cn = classLookup(ty);
|
|
String *ex;
|
|
String *ret;
|
|
if (!cn) {
|
|
if (add_to_hash) {
|
|
Setattr(undefined_types, ty, ty);
|
|
}
|
|
ret = NewString("Swigcptr");
|
|
ex = exportedName(ty);
|
|
Append(ret, ex);
|
|
} else {
|
|
String *cname = Getattr(cn, "sym:name");
|
|
if (!cname) {
|
|
cname = Getattr(cn, "name");
|
|
}
|
|
ex = exportedName(cname);
|
|
Node *cnmod = Getattr(cn, "module");
|
|
if (!cnmod || Strcmp(Getattr(cnmod, "name"), module) == 0) {
|
|
if (add_to_hash) {
|
|
Setattr(undefined_types, ty, ty);
|
|
}
|
|
ret = NewString("Swigcptr");
|
|
Append(ret, ex);
|
|
} else {
|
|
ret = NewString("");
|
|
Printv(ret, Getattr(cnmod, "name"), ".Swigcptr", ex, NULL);
|
|
}
|
|
}
|
|
Delete(ty);
|
|
Delete(ex);
|
|
return ret;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* gcCTypeForGoValue()
|
|
*
|
|
* Given a type, return the C/C++ type which will be used to catch
|
|
* the value in Go. This is the 6g/8g version.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *gcCTypeForGoValue(Node *n, SwigType *type, String *name) {
|
|
bool is_interface;
|
|
String *gt = goTypeWithInfo(n, type, &is_interface);
|
|
bool is_string = Strcmp(gt, "string") == 0;
|
|
bool is_slice = Strncmp(gt, "[]", 2) == 0;
|
|
bool is_function = Strcmp(gt, "_swig_fnptr") == 0;
|
|
bool is_member = Strcmp(gt, "_swig_memberptr") == 0;
|
|
bool is_complex64 = Strcmp(gt, "complex64") == 0;
|
|
bool is_complex128 = Strcmp(gt, "complex128") == 0;
|
|
bool is_int8 = false;
|
|
bool is_int16 = false;
|
|
bool is_int = Strcmp(gt, "int") == 0 || Strcmp(gt, "uint") == 0;
|
|
bool is_int32 = false;
|
|
bool is_int64 = false;
|
|
bool is_float32 = false;
|
|
bool is_float64 = false;
|
|
if ((n != NULL && Getattr(n, "tmap:gotype") != NULL) || hasGoTypemap(n, type)) {
|
|
is_int8 = Strcmp(gt, "int8") == 0 || Strcmp(gt, "uint8") == 0 || Strcmp(gt, "byte") == 0;
|
|
is_int16 = Strcmp(gt, "int16") == 0 || Strcmp(gt, "uint16") == 0;
|
|
is_int32 = Strcmp(gt, "int32") == 0 || Strcmp(gt, "uint32") == 0;
|
|
is_int64 = Strcmp(gt, "int64") == 0 || Strcmp(gt, "uint64") == 0;
|
|
is_float32 = Strcmp(gt, "float32") == 0;
|
|
is_float64 = Strcmp(gt, "float64") == 0;
|
|
}
|
|
Delete(gt);
|
|
|
|
String *ret;
|
|
if (is_string) {
|
|
// Note that we don't turn a reference to a string into a
|
|
// pointer to a string. Strings are immutable anyhow.
|
|
ret = NewString("_gostring_ ");
|
|
Append(ret, name);
|
|
return ret;
|
|
} else if (is_slice) {
|
|
// Slices are always passed as a _goslice_, whether or not references
|
|
// are involved.
|
|
ret = NewString("_goslice_ ");
|
|
Append(ret, name);
|
|
return ret;
|
|
} else if (is_function || is_member) {
|
|
ret = NewString("void *");
|
|
Append(ret, name);
|
|
return ret;
|
|
} else if (is_complex64) {
|
|
ret = NewString("_Complex float ");
|
|
} else if (is_complex128) {
|
|
ret = NewString("_Complex double ");
|
|
} else if (is_interface) {
|
|
SwigType *t = SwigType_typedef_resolve_all(type);
|
|
if (SwigType_ispointer(t)) {
|
|
SwigType_del_pointer(t);
|
|
}
|
|
if (SwigType_isreference(t)) {
|
|
SwigType_del_reference(t);
|
|
}
|
|
SwigType_add_pointer(t);
|
|
ret = SwigType_lstr(t, name);
|
|
Delete(t);
|
|
return ret;
|
|
} else {
|
|
SwigType *t = SwigType_typedef_resolve_all(type);
|
|
if (SwigType_isreference(t)) {
|
|
// A const reference to a known type, or to a pointer, is not
|
|
// mapped to a pointer.
|
|
SwigType_del_reference(t);
|
|
if (SwigType_isqualifier(t)) {
|
|
String *q = SwigType_parm(t);
|
|
if (Strcmp(q, "const") == 0) {
|
|
SwigType_del_qualifier(t);
|
|
if (hasGoTypemap(n, t) || SwigType_ispointer(t)) {
|
|
if (is_int) {
|
|
ret = NewString("intgo ");
|
|
Append(ret, name);
|
|
} else if (is_int64) {
|
|
ret = NewString("long long ");
|
|
Append(ret, name);
|
|
} else {
|
|
ret = SwigType_lstr(t, name);
|
|
}
|
|
Delete(q);
|
|
Delete(t);
|
|
return ret;
|
|
}
|
|
}
|
|
Delete(q);
|
|
}
|
|
}
|
|
|
|
if (Language::enumLookup(t) != NULL) {
|
|
is_int = true;
|
|
} else {
|
|
SwigType *tstripped = SwigType_strip_qualifiers(t);
|
|
if (SwigType_isenum(tstripped))
|
|
is_int = true;
|
|
Delete(tstripped);
|
|
}
|
|
|
|
Delete(t);
|
|
if (is_int8) {
|
|
ret = NewString("char ");
|
|
} else if (is_int16) {
|
|
ret = NewString("short ");
|
|
} else if (is_int) {
|
|
ret = NewString("intgo ");
|
|
} else if (is_int32) {
|
|
ret = NewString("int ");
|
|
} else if (is_int64) {
|
|
ret = NewString("long long ");
|
|
} else if (is_float32) {
|
|
ret = NewString("float ");
|
|
} else if (is_float64) {
|
|
ret = NewString("double ");
|
|
} else {
|
|
return SwigType_lstr(type, name);
|
|
}
|
|
}
|
|
|
|
if (SwigType_isreference(type)) {
|
|
Append(ret, "* ");
|
|
}
|
|
Append(ret, name);
|
|
return ret;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* gccgoCTypeForGoValue()
|
|
*
|
|
* Given a type, return the C/C++ type which will be used to catch
|
|
* the value in Go. This is the gccgo version.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *gccgoCTypeForGoValue(Node *n, SwigType *type, String *name) {
|
|
return gcCTypeForGoValue(n, type, name);
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* goTypeIsInterface
|
|
*
|
|
* Return whether this C++ type is represented as an interface type
|
|
* in Go. These types require adjustments in the Go code when
|
|
* passing them back and forth between Go and C++.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
bool goTypeIsInterface(Node *n, SwigType *type) {
|
|
bool is_interface;
|
|
Delete(goTypeWithInfo(n, type, &is_interface));
|
|
return is_interface;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* hasGoTypemap
|
|
*
|
|
* Return whether a type has a "gotype" typemap entry.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
bool hasGoTypemap(Node *n, SwigType *type) {
|
|
Parm *p = NewParm(type, "test", n);
|
|
SwigType *tm = Swig_typemap_lookup("gotype", p, "", NULL);
|
|
Delete(p);
|
|
if (tm && Strstr(tm, "$gotypename") == 0) {
|
|
Delete(tm);
|
|
return true;
|
|
}
|
|
Delete(tm);
|
|
return false;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* goEnumName()
|
|
*
|
|
* Given an enum node, return a string to use for the enum type in Go.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
String *goEnumName(Node *n) {
|
|
String *ret = Getattr(n, "go:enumname");
|
|
if (ret) {
|
|
return Copy(ret);
|
|
}
|
|
|
|
if (Equal(Getattr(n, "type"), "enum ")) {
|
|
return NewString("int");
|
|
}
|
|
|
|
String *type = Getattr(n, "enumtype");
|
|
assert(type);
|
|
char *p = Char(type);
|
|
int len = Len(type);
|
|
String *s = NewString("");
|
|
bool capitalize = true;
|
|
for (int i = 0; i < len; ++i, ++p) {
|
|
if (*p == ':') {
|
|
++i;
|
|
++p;
|
|
assert(*p == ':');
|
|
capitalize = true;
|
|
} else if (capitalize) {
|
|
Putc(toupper(*p), s);
|
|
capitalize = false;
|
|
} else {
|
|
Putc(*p, s);
|
|
}
|
|
}
|
|
|
|
ret = Swig_name_mangle(s);
|
|
Delete(s);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* getParm()
|
|
*
|
|
* Get the real parameter to use.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
Parm *getParm(Parm *p) {
|
|
while (p && checkAttribute(p, "tmap:in:numinputs", "0")) {
|
|
p = Getattr(p, "tmap:in:next");
|
|
}
|
|
return p;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* nextParm()
|
|
*
|
|
* Return the next parameter.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
Parm *nextParm(Parm *p) {
|
|
if (!p) {
|
|
return NULL;
|
|
} else if (Getattr(p, "tmap:in")) {
|
|
return Getattr(p, "tmap:in:next");
|
|
} else {
|
|
return nextSibling(p);
|
|
}
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* isStatic
|
|
*
|
|
* Return whether a node should be considered as static rather than
|
|
* as a member.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
bool isStatic(Node *n) {
|
|
String *storage = Getattr(n, "storage");
|
|
return (storage && (Swig_storage_isstatic(n) || Strcmp(storage, "friend") == 0) && (!SmartPointer || !Getattr(n, "allocate:smartpointeraccess")));
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* isFriend
|
|
*
|
|
* Return whether a node is a friend.
|
|
* ---------------------------------------------------------------------- */
|
|
|
|
bool isFriend(Node *n) {
|
|
String *storage = Getattr(n, "storage");
|
|
return storage && Strcmp(storage, "friend") == 0;
|
|
}
|
|
|
|
}; /* class GO */
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* swig_go() - Instantiate module
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
static Language *new_swig_go() {
|
|
return new GO();
|
|
}
|
|
extern "C" Language *swig_go(void) {
|
|
return new_swig_go();
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* Static member variables
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
// Usage message.
|
|
const char * const GO::usage = (char *) "\
|
|
Go Options (available with -go)\n\
|
|
-gccgo - Generate code for gccgo rather than 6g/8g\n\
|
|
-go-pkgpath <p> - Like gccgo -fgo-pkgpath option\n\
|
|
-go-prefix <p> - Like gccgo -fgo-prefix option\n\
|
|
-intgosize <s> - Set size of Go int type--32 or 64 bits\n\
|
|
-package <name> - Set name of the Go package to <name>\n\
|
|
-use-shlib - Force use of a shared library\n\
|
|
-soname <name> - Set shared library holding C/C++ code to <name>\n\
|
|
\n";
|